1、 Spring

1、简介

• 2002 首次推出了Spring框架的雏形：interface21框架
• Spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架
• 官网：https://spring.io/projects/spring-framework
• 官方下载地址：
• Github：https://github.com/spring-projects/spring-framework

jar包

<dependencies><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.2.9.RELEASE</version></dependency></dependencies>

2、优点

• Spring是一个免费的框架（容器）
• Spring是一个轻量级的、非入侵式的框架
• 控制反转（IOC)，面向切面编程（AOP）
• 支持事务的处理，对框架整合的支持！

总结：Spring就是一个轻量级的控制反转(IOC)和面向切面编程（AOC）的框架！

3、组成

4、拓展

现代化java开发，就是基于Spring的开发！

• Spring Boot

  1、一个快速开发的脚手架

  2、基于SpringBoot可以快速开发单个的微服务

  3、约定大于配置！

• Spring Cloud

  1、SpringCloud是基于SpringBoot实现的

注：学习SpringBoot的前提需要完全掌握Spring及SpringMVC！

弊端：发展了太久，违背了原来的理念！配置十分繁琐，人称“配置地狱！”

2、IOC理论推导

1. User接口
2. UserImpl实现类
3. UserService业务接口
4. UserServiceImpl业务实现类

在我们之前的也业务中，用户的需求可能会影响我们的代码，我们需要根据用户的需求去修改代码，如果程序的代码量十分大，修改一次的成本代价十分昂贵！

我们使用一个set接口实现，代码已经发生了革命性的变化！

public class UserServiceImpl implements UserService {private User user;//利用set进行松台实现值的注入public void setUser(User user) {this.user = user;}

• 之前，程序是主动创建对象，控制权在程序猿手上!
• 使用了set注入之后，程序不再具有主动性，而是变成了被动的接受对象

这种思想，从本质上解决了问题，我们程序猿不用再去管理对象的创建了。系统的耦合性大大降低，可以更加专注的在业务的实现上！这就是IOC的原型！

IOC本质

控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。

3、HelloSpring

实体类的set注入方法

public class Hello {private String str;public String getStr() {return str;}public void setStr(String str) {this.str = str;}

将实体类注册到配置文件中

<!--使用Spring来创建对象，在Spring这些都称为Bean--><bean id="hello" class="com.kuang.pojo.Hello"><property name="str" value="核力量"/></bean>

测试

public static void main(String[] args) {//获取Spring的上下文对象！ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");//我们的对象都在Spring中管理了，我们要使用，直接去里面取出来就可以！Hello hello = (Hello)context.getBean("hello");System.out.println(hello.toString());}

思考问题？

• Hello对象是谁创建的？
  hello对象是由Spring创建的
• Hello对象的属性是怎么设置的？
  hello对象的属性是由Spring容器设置的

这个过程就叫控制反转

• 控制：传统应用程序的对象是由程序本身创建的，使用Spring后，对象是由Spring来创建的
• 反转：程序本身不创建对象，而变成被动的接受对象
• 依赖注入：就是利用set方法来进行注入的
• IOC是一种编程思想，由主动的编程变成被动的接受
• 可以通过new ClassPathXmlApplicationContext 浏览一下底层源码

OK,到了现在，我们彻底不用在程序中去改动了，要实现不同的操纵，只需要在xml配置中进行修改，所谓的IOC，一句话搞定：对象由Spring来创建，管理，装配！

4、IOC创建对象的方式

1. 使用无参构造创建对象，默认！
2. 使用有参构造创建对象
   参数下标赋值

<!--第一种：下标赋值--><bean id="user" class="com.kuang.pojo.User"><constructor-arg index="0" value="昂给"/></bean>

参数类型赋值

<!--第二种：通过类型创建--><bean id="user" class="com.kuang.pojo.User"><constructor-arg type="java.lang.String" value="回家看了"/></bean>

参数名赋值

<!--第三种：直接通过参数名创建--><bean id="user" class="com.kuang.pojo.User"><constructor-arg name="name" value="后i"/></bean>

总结：在配置文件加载的时候，容器中管理的对象就已经被初始化了！

5、Spring配置

1、别名

<!--使用别名获取到这个对象--><alias name="user" alias="user2"/>

2、Bean的配置

<!--id:bean的唯一标识符，相当于对象名class:bean 对象所对应的全限定名：包名+类型name:别名，可以同时取多个别名--><bean id="user" class="com.kuang.pojo.User" name="user2;u2,u3 u4"><constructor-arg name="name" value="后i"/></bean>

3、import

import一般用于团队开发使用，可以将多个配置文件导入applicationContext.xml合并为一个

   <import resource="beans.xml"/><import resource="beans1.xml"/><import resource="beans2.xml"/>

6、DI依赖注入

1、构造器注入

依赖注入：Set注入！
依赖：bean对象的创建依赖于容器
注入：bean对象中的所有属性

2、Set方式注入【重点】

【环境搭建】

1. 复杂类型

public class Address {private String address;public String getAddress() {return address;}public void setAddress(String address) {this.address = address;}
}

1. 真实测试对象

public class Student {private String name;private String wife;private Address address;private String[] books;private List<String> hobbys;private Map<String,String> card;private Set<String> games;private Properties info;

1. applicationContext.xml

<!--各种注入方式-->
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><bean id="address" class="com.kuang.pojo.Address"/><bean id="student" class="com.kuang.pojo.Student"><!--普通值注入，value--><property name="name" value="狠人大帝"/><!--bean注入，ref--><property name="address" ref="address"/><!--数组注入--><property name="books"><array><value>西游记</value><value>三国演义</value><value>红楼梦</value><value>水浒传</value></array></property><!--List注入--><property name="hobbys"><list><value>听歌</value><value>敲代码</value><value>看电影</value></list></property><!--Map注入--><property name="card"><map><entry key="耳根" value="《仙逆》"/><entry key="辰东" value="《完美世界》"/><entry key="猫腻" value="《大道朝天》"/></map></property><!--Set注入--><property name="games"><set><value>植物大战僵尸</value><value>城市天际线</value><value>保卫萝卜</value></set></property><!--null--><property name="wife" ><null/></property><!--properties--><property name="info"><props><prop key="driver">4567645674</prop><prop key="id">4567645674</prop><prop key="pwd">4567645674</prop></props></property></bean></beans>

4.测试类

public class MyTest {public static void main(String[] args) {ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");Student student = (Student) context.getBean("student");System.out.println(student.getAddress());}
}

3、拓展方式注入

我们可以使用p命名空间和c命名空间注入

使用！

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:p="http://www.springframework.org/schema/p"xmlns:c="http://www.springframework.org/schema/c"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"><!--P命名空间注入，可以直接注入属性：property--><bean id="user" class="com.kuang.pojo.User" p:age="18" p:name="哈克"/><!--C命名空间注入，通过构造器注入：conStruct-args--><bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="哈g克"/>
</beans>

注意：p命名空间和c命名空间不能直接使用，需要导入xml约束

xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"

4、bean的作用域

1. 单例模式（Spring默认机制）

    <bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="哈g克" scope="singleton"/>

1. 原型模式：每次从容器中get的时候，都会产生一个新对象！

    <bean id="user2" class="com.kuang.pojo.User" c:age="18" c:name="哈g克" scope="prototype"/>

1. 其余的request、session、application 、这些个只能在web开发中使用到！

7、Bean的自动装配

• 自动装配是Spring满足bean依赖注入的一种方式！
• Spring会在上下文中自动寻找，并自动给bean装配属性！

在Spring中有三种装配方式

1. 在xml中显示的配置
2. 在java中显示配置
3. 隐式的自动装配bean【重要】

1、测试

环境搭建：一个人有两个宠物

2、ByName自动装配

<bean id="cat" class="com.kuang.pojo.Cat"/><bean id="dog" class="com.kuang.pojo.Dog"/><!--ByNmae：会自动在容器上下文中查找，和自己对象set方法后面的值对应的beanId！--><bean id="people" class="com.kuang.pojo.People" autowire="byName"><property name="name" value="杨戬"/></bean>

3、ByType自动装配

<bean id="cat" class="com.kuang.pojo.Cat"/><bean id="dog222" class="com.kuang.pojo.Dog"/><!--ByNmae：会自动在容器上下文中查找，和自己对象属性相同的bean！--><bean id="people" class="com.kuang.pojo.People" autowire="byType"><property name="name" value="杨戬"/></bean>

小结：

• ByName的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性set方法的值一致
• ByName的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致

4、使用注解实现自动装配

jdk1.5支持的注解，Spring2.5就支持注解了

要使用注解须知：

1. 导入约束，context约束
2. 配置注解的支持: context:annotation-config/

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beanshttps://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttps://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/aophttps://www.springframework.org/schema/aop/spring-aop.xsd"><!--注解的支持--><context:annotation-config/></beans>

• AutoWired
  直接在属性上使用即可，也可以在set方法上使用！
  使用Autowired我们可以不用编写Set方法了，前提是你这个自动装配的属性在IOC（Spring）容器中存在，且符合名字ByName！

public class People {private String name;@Autowiredprivate Cat cat;@Autowiredprivate Dog dog;

科普：

@Nullable 字段标记了这个注解，说明这个字段可以为null。

@Autowired：

public @interface Autowired {boolean required() default true;
}

测试代码

ublic class People {private String name;//如果显示定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空@Autowired(required = false)private Cat cat;@Autowiredprivate Dog dog;

如果@Autowired自动装配环境比较复杂，自动装配无法通过一个注解【@Autowired】确定唯一完成的时候，我们可以使用@Quailefier（value=“xxx”）去配合具体限定唯一的bean对象注入！

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="dog22" class="com.kuang.pojo.Dog"/>

public class People {private String name;//如果显示定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空@Autowiredprivate Cat cat;@Autowired@Qualifier(value = "dog22")private Dog dog;

@Resource注解：jdk类库中提供的注解

@Resource(name = "cat2")
private Cat cat;

<bean id="cat1" class="com.kuang.pojo.Cat"/>
<bean id="cat2" class="com.kuang.pojo.Cat"/>

小结：
@Autowired注解和@Resource注解的区别

• 都是用来自动装配的，都可以放在属性字段上
• @Autowired通过byType的方式实现，而且必须要求这个对象存在【常用】
• @Autowired先是根据类型注入，找出来不止一个的话会根据名字注入
• @resource默认通过byType的方式实现，有多个再根据名字注入！两个都找不到，就报错！【常用】

8、使用注解开发

再Spring4之后，要使用注解开发，必须保证aop的包导入

使用注解需要导入context约束，增加注解的支持！

1. bean
2. 属性如何注入

@Component
public class User {@Value("青山归井九")public String name;
}

1. 衍生的注解
   @Component有几个衍生的注解，我在web开发中，会按照MVC三层架构分层！

   dao【@Repository】
   service【@Service】
   controller【@Controller】

这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean

1. 自动装配置

@Autowired：自动装配通过类型，名字如果@Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value = "xxx")
@Nullable：字段标记了这个注解，说明这个字段可以为null
@resource：自动装配，通过名字，类型。

1. 作用域

@Component
@Scope("prototype")
public class User {@Value("青山归井九")public String name;
}

1. 小结：
   xml与注解：

   xml更加万能，适用于任何场合！维护简单方便

   注解不是自己的类使用不了，维护相对复杂

   xml与注解的最佳实践：

   xml用来管理bean

   注解只负责完成属性的注入

   9、使用Java的方式配置Spring

   我们现在要完全不使用Sprig的xml配置了，全权交给java来做！

   JavaConfig是Spring的一个子项目，在Spring4之后，他成为了一个核心功能

实体类

package com.kuang.pojo;import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;//这个注解的意思是，就是说明这个类被Spring接管了，注册人到了容器中
@Component
public class User {@Value("hi哦")private String name;public String getName() {return name;}public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "User{" +"name='" + name + '\'' +'}';}
}

配置文件

@Configuration//这个也会被Spring容器托管，注册到容器中，因为他本来就是一个@Component
@ComponentScan("com.kuang.pojo")
@Import(KuangConfig2.class)
public class KuangConfig {@Beanpublic User getUser(){return new User();}
}

测试类

import com.kuang.pojo.User;
import com.kuang.pojo.config.KuangConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;public class MyTest {public static void main(String[] args) {//如果完全使用了配置类的方式去做，我们就只能通过AnnotationConfig上下文来获取容器，通过配置类的class对象加载！ApplicationContext context = new AnnotationConfigApplicationContext(KuangConfig.class);User getUser = (User) context.getBean("getUser");System.out.println(getUser.getName());}
}

这种纯java的配置方式，在SpringBoot中随处可见

10、代理模式

为什么要学习代理模式？因为这就是SpringAOP的底层！
代理模式的分类：

• 静态代理
• 动态代理

1、静态代理：

角色分析

• 抽象角色：一般会使用接口或者抽象类来解决
• 真实角色： 被代理的角色
• 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
• 客户：访问代对象的人

代码步骤

• 接口

package com.kuang.demo01;public interface Rent {public void rent();
}

• 真实角色

package com.kuang.demo01;//房东
public class LandLord implements Rent{@Overridepublic void rent() {System.out.println("房东要出租房子了");}
}

• 代理角色

package com.kuang.demo01;public class Proxy implements Rent{private LandLord host;public Proxy() {}public Proxy(LandLord host) {this.host = host;}@Overridepublic void rent() {seeHouse();feeHouse();host.rent();contract();}//看房public void seeHouse(){System.out.println("中介带你看房");}//看房public void feeHouse(){System.out.println("中介收费");}//看房public void contract(){System.out.println("中介和你签合同");}
}

• 客户端访问代理角色

package com.kuang.demo01;public class Client {public static void main(String[] args) {//房东要租房子LandLord host = new LandLord();//代理，中介，有附加操作Proxy proxy = new Proxy(host);//找中介租房proxy.rent();}
}

代理模式的好处

• 可以使真实角色的操作更加纯粹，不用去关注一些公共业务
• 公共业务就交给代理就角色，实现了业务的分工
• 公共业务发生拓展的时候，方便集中管理

缺点

• 要给真实角色就会产生一个代理角色，代码量会翻倍，开发效率降低

2、加深理解

3、动态代理

• 动态代理和静态代理角色一样
• 动态代理的代理类是动态生成的，不是我们直接写好的
• 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
  1. 基于接口----JDK动态代理
  2. 基于类----cglib
  3. Java字节码实现

需要了解两个类：Proxy：动态生成代理类的静态方法，InvocationHandler：调用处理程序（实现方法），并返回一个结果

动态代理的好处：

• 可以使真实角色的操作更加纯粹，不用去关注一些公共业务
• 公共业务就交给代理就角色，实现了业务的分工
• 公共业务发生拓展的时候，方便集中管理
• 一个动态代理类代理的是一个接口，一般就是对应的一类业务
• 一个动态代理类可以代理多个类，只要实现了同一个接口即可

要代理的接口

package com.kuang.demo01;public interface Rent {public void rent2();
}

实现接口的类

package com.kuang.demo01;//房东
public class LandLord implements Rent{@Overridepublic void rent2() {System.out.println("房东要出租房子了");}public void rent3(){System.out.println("房东出大房子");}
}

代理类

package com.kuang.demo01;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;//用这个类，自动生成代理类
public class ProxyInvocatinHandler implements InvocationHandler {//被代理的接口private Object target;public void setTarget(Object target) {this.target = target;}//生成得到代理类public Object getProxy(){return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);}@Override//处理代理实例，并返回结果public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {log(method.getName());Object result = method.invoke(target, args);return result;}public void log(String msg){System.out.println("执行了"+msg+"方法");
}}

用户通过代理类租房

    public static void main(String[] args) {//真实角色LandLord host = new LandLord();//代理角色ProxyInvocatinHandler handler = new ProxyInvocatinHandler();//设置要代理的对象handler.setTarget(host);//动态生成代理类Rent proxy = (Rent) handler.getProxy();//找中介租房proxy.rent2();}
}

11、AOP

1、什么是AOP

在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

AOP在Spring中的作用

提供声明式服务；允许用户自定义切面

横切关注点:跨越应用程序多个模块的方法或功能.既是,与我们业务逻辑无关,但是我们需要关注的部分,就是横切关注点.如日志,安全,缓存,事务等…

• 切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。

• 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。

• 目标（Target）：被通知对象。

• 代理（Proxy）：向目标对象应用通知之后创建的对象。

• 切入点（PointCut）：切面通知 执行的 “地点”的定义。

• 连接点（JointPoint）：与切入点匹配的执行点。

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5中类型的Advice

即AOP在不改变原有代码的情况下，去增加新的功能

3、使用Spring实现AOP

使用AOP织入，需要导入一个依赖包！

<dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.4</version></dependency>

方式一：使用Spring的API接口

切入点前切入的类

package com.kuang.log;import org.springframework.aop.MethodBeforeAdvice;import java.lang.reflect.Method;public class Log implements MethodBeforeAdvice {//method：要执行的目标对象方法//args：参数//target：目标对象@Overridepublic void before(Method method, Object[] args, Object target) throws Throwable {System.out.println(target.getClass().getName()+"的"+method.getName()+"被执行了");}
}

切入点后切入的类

package com.kuang.log;import org.springframework.aop.AfterReturningAdvice;import java.lang.reflect.Method;public class AfterLog implements AfterReturningAdvice {//returnValue：返回值@Overridepublic void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {System.out.println("执行了"+method.getName()+"返回了"+returnValue);}
}

applicationContext.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop.xsd"><!--注册bean--><bean id="afterLog" class="com.kuang.log.AfterLog"/><bean id="log" class="com.kuang.log.Log"/><!--方式一：使用原声的Spring API接口--><!--配置 AOP:需要导入AOP的约束--><aop:config><!--切入点：expression：表达式 ,execution(要执行的位置！)里面写（修饰词 返回值 类名 方法名 参数）--><aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/><!--执行环绕增加     切入的方法              切入点--><aop:advisor advice-ref="log" pointcut-ref="pointcut"/><aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/></aop:config>
</beans>

测试：

public class MyTest {public static void main(String[] args) {ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");//动态代理的是接口UserService userService = (UserService) context.getBean("userServiceImpl");userService.add();}
}

方式二：自定义类

package com.kuang.diy;public class diyLog {public void before(){System.out.println("前");}public void after(){System.out.println("后");}
}

applicationContext.xml

    <bean id="diy" class="com.kuang.diy.diyLog"/><aop:config><!--自定义切面--><aop:aspect ref="diy"><!--切入点--><aop:pointcut id="point" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/><!--通知--><aop:before method="before" pointcut-ref="point"/><aop:after method="after" pointcut-ref="point"/></aop:aspect></aop:config>

方式三：注解实现
自定义类

package com.kuang.diy;import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;//使用注解方式实现AOP
@Aspect//标注这个类是个切面
public class AnnotationPointCut {@Before("execution(* com.kuang.service.UserServiceImpl.*(..))")public void befor(){System.out.println("qian");}@After("execution(* com.kuang.service.UserServiceImpl.*(..))")public void after(){System.out.println("hou");}
}

applicationContext

<bean id="annoPoint" class="com.kuang.diy.AnnotationPointCut"/><!--支持--><aop:aspectj-autoproxy/>

12、整合Mybatis

1、导入相关jar包

• junit
• mybatis
• mysql数据库
• spring相关的
• aop织入
• mybatis-spring

<dependencies><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.12</version></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.22</version></dependency><dependency><groupId>org.mybatis</groupId><artifactId>mybatis</artifactId><version>3.5.2</version></dependency><dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.1.9.RELEASE</version></dependency><!--Spring操作数据库，需要spring-jdbc--><dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.3.3</version></dependency><dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.4</version></dependency><!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring --><dependency><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId><version>2.0.5</version></dependency></dependencies>

2、编写配置文件

3、测试

2、Mybatis-Spring【详见狂神视频】

• 编写数据源配置
• sqlSessionfatroy
• sqlSessionTemplate
• 需要给接口加实现类【】
• 将自己写的实现类注入到Spring中测试使用

13、声明式事务

1、回顾事务

• 把一组业务当成一个业务来做 要么都成功，要么都失败！
• 事务项目的开发中，十分的重要，涉及到数据一致性的问题，不能马虎
• 确保完整性和一致性

事务ACID原则

• 原子性
• 一致性
• 隔离性：多个业务可能操作同一个资源，防止数据损坏
• 持久性：事务一旦提交，无论系统发生什么问题吗，结果都不会被影响，被持久化的写到存储器中

Spring5 详解 B站 狂神 学习笔记相关推荐

1. 各种音视频编解码学习详解之 编解码学习笔记（四）：Mpeg系列——Mpeg 4

   最近在研究音视频编解码这一块儿,看到@bitbit大神写的[各种音视频编解码学习详解]这篇文章,非常感谢,佩服的五体投地.奈何大神这边文章太长,在这里我把它分解成很多小的篇幅,方便阅读.大神博客传送门 ...

2. 各种音视频编解码学习详解之 编解码学习笔记（十三）：容器

   最近在研究音视频编解码这一块儿,看到@bitbit大神写的[各种音视频编解码学习详解]这篇文章,非常感谢,佩服的五体投地.奈何大神这边文章太长,在这里我把它分解成很多小的篇幅,方便阅读.大神博客传送门 ...

3. 各种音视频编解码学习详解之 编解码学习笔记（三）：Mpeg系列——Mpeg 1和Mpeg 2

   最近在研究音视频编解码这一块儿,看到@bitbit大神写的[各种音视频编解码学习详解]这篇文章,非常感谢,佩服的五体投地.奈何大神这边文章太长,在这里我把它分解很多小的篇幅,方便阅读.大神博客传送门: ...

4. 各种音视频编解码学习详解之 编解码学习笔记（八）：Real系列

   最近在研究音视频编解码这一块儿,看到@bitbit大神写的[各种音视频编解码学习详解]这篇文章,非常感谢,佩服的五体投地.奈何大神这边文章太长,在这里我把它分解成很多小的篇幅,方便阅读.大神博客传送门 ...

5. 各种音视频编解码学习详解之 编解码学习笔记（六）：H.26x系列

   最近在研究音视频编解码这一块儿,看到@bitbit大神写的[各种音视频编解码学习详解]这篇文章,非常感谢,佩服的五体投地.奈何大神这边文章太长,在这里我把它分解成很多小的篇幅,方便阅读.大神博客传送门 ...

6. 各种音视频编解码学习详解之 编解码学习笔记（十）：Ogg系列

   最近在研究音视频编解码这一块儿,看到@bitbit大神写的[各种音视频编解码学习详解]这篇文章,非常感谢,佩服的五体投地.奈何大神这边文章太长,在这里我把它分解成很多小的篇幅,方便阅读.大神博客传送门 ...

7. 孙鑫VC++深入详解第三章学习笔记

   第三章 3.1创建MFC AppWizard 如何利用vs2019创建MFC应用见参考文献[1] 需要注意的地方有 [1] 创建MFC单文档应用程序 [2]开启类视图窗口 3.2基于MFC的程序框架剖 ...

8. TCP/IP详解 卷1:协议 学习笔记 第十六章 BOOTP:引导程序协议

   一个无盘系统在不知道自身IP地址情况下,进行系统引导时能通过RARP协议获取它的IP地址,使用RARP会有两个问题:(1)IP地址是返回的唯一结果:(2)RARP使用链路层广播,RARP请求不会被路由 ...

9. Spring5（引用--＞狂神学习笔记）2021-08

   狂神学习笔记 Spring5 1.Spring 1.1 简介 2002,首次推出Spring框架的雏形;interface21框架 Spring框架以interface21框架为基础,2004年发布1 ...

最新文章

1. 【PHPWord】TextRun
2. 高级指令——top指令【作用：查看服务器的进程占的资源】、du -sh指令【作用：查看目录的真实大小】、find指令【作用：用于查找文件】、service指令
3. 数据库并发一致性的问题
4. 《解密小米之互联网下的商业奇迹》
5. Spring Cloud Alibaba基础教程：与Dubbo的完美融合
6. 8 一点就消失_消失的莉莉安（25）
7. Django的 select_related 和 prefetch_related 函数对 QuerySet 查询的优化（二）
8. 简单的签到代码_签到功能，用 MySQL 还是 Redis ？
9. 农广传媒获中体基金2000万元Pre-A轮融资
10. 卸载python会删除pip安装的包吗_python 使用pip安装，卸载，升级和查看包
11. java mail报权限问题
12. 常用排序算法：直接插入排序
13. Ubuntu 16.04 一系列软件安装命令，包括QQ、搜狗、Chrome、vlc、网易云音乐安装方法
14. 图像检索：基于内容的图像检索技术
15. FC冒险岛java版_FC冒险岛全关卡版
16. RIME输入法配置双拼方案（Ubuntu下基于ibus）
17. 智能制造怎么精益生产？详解：精益生产与智能制造的融合
18. （nlogn）的时间复杂度求 最近点对 hdu 1007 凹凸曼与小怪兽的故事 poj3714 Raid...
19. 小程序图片底部留白问题
20. 垃圾收集器以及三色标记

热门文章

1. 建立自己的私有云储存服务【ownCloud】
2. ubuntu18.04搭建socks5代理服务器
3. dns服务器 、dns中间人篡改服务器
4. 一天连续两场活动，唐胡子俱乐部的魅力是什么？
5. 区块链-4：区块链的基本类型和智能合约
6. serializeArray()和serialize()方法的用法和区别。
7. Docker实操3——配置强化学习环境镜像
8. 基于蜂虎狩猎 (BEH) 算法求解单目标优化问题附matlab代码
9. 如何成为一名大学老师
10. 获取当年所有工作日及节假日信息