spring

  Spring : 春天 --->给软件行业带来了春天
    2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。
    2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。
    很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。
    Spring理念 : 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术
    官网 : http://spring.io/
    官方下载地址 : https://repo.spring.io/libs-release-local/org/springframework/spring/
    GitHub : https://github.com/spring-projects

2、依赖

在maven工程下的pom.xml中导入spring

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

3、优点

Spring是一个开源的免费的框架
Spring是一个轻量级的，非入侵式的框架
控制反转（IOC），面向切面编程（AOP）
支持事务的处理，对框架整合的支持
总结：Spring是一个轻量级的控制反转（IOC）和面向切面编程（AOP）Spring是一个开源的免费的框架

4、Spring Boot与Spring Cloud

        Spring Boot 是 Spring 的一套快速配置脚手架，可以基于Spring Boot 快速开发单个微服务;
        Spring Cloud是基于Spring Boot实现的；
        Spring Boot专注于快速、方便集成的单个微服务个体，Spring Cloud关注全局的服务治理框架；
        Spring Boot使用了约束优于配置的理念，很多集成方案已经帮你选择好了，能不配置就不配置 , Spring Cloud很大的一部分是基于Spring Boot来实现，Spring Boot可以离开Spring Cloud独立使用开发项目，但是Spring Cloud离不开Spring Boot，属于依赖的关系。
        SpringBoot在SpringClound中起到了承上启下的作用，如果你要学习SpringCloud必须要学习SpringBoot。

2、IOC理论推导

2.1、IOC的原型

代码分为dao层和service层，之后web层的处理都会使用service层，如果一个dao接口类有多个实现类在service层设置一个方法，该方法用于设置某个接口dao的具体实现类，可以实现不触碰dao层的情况下随意切换不同的dao层实现类

public class UserServiceImpl implements UserService {
    private UserDao userDao;
    public void setUserDao(UserDao userDao){
        this.userDao=userDao;
    }
}

使用该方法，把主动权交给了调用者，程序不用去管怎么创建,怎么实现了。它只负责提供一个接口。
这种思想,从本质上解决了问题,我们程序员不再去管理对象的创建了,更多的去关注业务的实现。耦合性大大降低。这也就是IOC的原型 !

2.2、IOC本质

控制反转IoC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IoC的一种方法，

IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IoC。
IoC,一句话搞定 : 对象由Spring 来创建 , 管理 , 装配 !

控制反转 :
控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的。
反转 : 程序本身不创建对象 , 而变成被动的接收对象 .
依赖注入 : 就是利用set方法来进行注入的.
IOC是一种编程思想，由主动的编程变成被动的接收

2.3、IOC创建对象的方式

1、通过无参构造方法来创建

<bean id="hello" class="pojo.Hello">
</bean>

2、通过有参构造方法来创建

<!-- 第一种根据index参数下标设置 -->
    <bean id="hello" class="pojo.Hello">
        <!-- index指构造方法 , 下标从0开始 -->
        <constructor-arg index="0" value="Spring"/>
    </bean>
<!-- 第二种根据参数名字设置-->
   <bean id="hello" class="pojo.Hello">
       <!-- name指参数名 -->
       <constructor-arg name="name" value="Spring2"/>
   </bean>
<!-- 第三种根据参数类型设置 -->
    <bean id="hello" class="pojo.Hello">
        <constructor-arg type="java.lang.String" value="Spring3"/>
    </bean>

在配置文件加载的时候。其中管理的对象都已经初始化了！

3、Spring配置

3.1、别名

alias为bean设置别名,可以设置多个别名，name值填写对应的id值

<!--设置别名：在获取Bean的时候可以使用别名获取-->
<alias name="userT" alias="userNew"/>

3.2、bean配置

<!--
   id 是bean的标识符,要唯一,如果没有配置id,name就是默认标识符
   name可以设置多个别名,可以用逗号,分号,空格隔开。如果配置id,又配置了name,那么name是别名
   class是bean的全限定名=包名+类名，如果不配置id和name,可以根据applicationContext.getBean(.class)获取对象;
-->
<bean id="hello" name="hello2 h2,h3;h4" class="com.kuang.pojo.Hello">
   <property name="name" value="Spring"/>
</bean>

3.3、import

假设项目中有多个bean.xml，通过import可以将多个bean.xml导入到一个总的bean.xml。使用时使用总的配置文件即可。

<import resource="{path}/beans.xml"/>
<import resource="{path}/beans2.xml"/>

4、依赖注入（DI）

三种注入方式：构造器注入、set注入、其他注入。

4.1、依赖注入：属于set注入！

依赖 : 指Bean对象的创建依赖于容器。Bean对象的依赖资源。
注入 : 指Bean对象所依赖的资源 , 由容器来设置和装配。

4.2、注入

1、常量注入

<bean id="student" class="com.kuang.pojo.Student">
   <property name="name" value="小明"/>
</bean>

2、Bean注入
注意点：这里的值是一个引用，ref

<bean id="addr" class="pojo.Address">
  <property name="address" value="重庆"/>
</bean>
<bean id="student" class="pojo.Student">
  <property name="name" value="小明"/>
  <property name="address" ref="addr"/>
</bean>

3、数组注入

<bean id="student" class="pojo.Student">
  <property name="books">
      <array>
          <value>西游记</value>
          <value>红楼梦</value>
          <value>水浒传</value>
      </array>
  </property>
</bean>

4、List注入

<property name="hobbys">
   <list>
      <value>唱歌</value>
      <value>画画</value>
      <value>跳舞</value>
   </list>
</property>

5、Map注入

<property name="card">
   <map>
       <entry key="身份证" value="222222222"/>
       <entry key="银行卡" value="333333333"/>
   </map>
</property>

6、set注入

<property name="games">
    <set>
        <value>LOL</value>
        <value>BOB</value>
        <value>COC</value>
    </set>
</property>

7、Null注入

<property name="wife"><null/></property>

8、Properties注入

private Properties info;
<property name="info">
    <props>
        <prop key="学号">20190604</prop>
        <prop key="性别">男</prop>
        <prop key="姓名">小明</prop>
    </props>
</property>

4.3、p命名和c命名注入

1、p命名：

导入约束：xmlns:p="http://www.springframework.org/schema/p"
可以直接使用p:属性名="" 给属性赋值。属于set注入，必须有属性的set方法！
<bean id="hello" class="pojo.Hello" p:name="张三" p:age="34"></bean>

2、c命名

导入约束： xmlns:c="http://www.springframework.org/schema/c"
可以直接使用c:属性名="" 给属性赋值。属于构造器注入，必须有有参构造器！
<bean id="hello" class="pojo.Hello" c:name="张三" c:age="34"></bean>

4.4、Bean的作用域

1、单例模式：Singleton（默认）

Spring IoC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。

2、原型模式：Prototype

表示一个bean定义对应多个对象实例。Prototype作用域的bean会导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）时都会创建一个新的bean实例。

3、request、session、application 、这些只能在web开发中使用到

3.1、Request
当一个bean的作用域为Request，表示在一次HTTP请求中，一个bean定义对应一个实例；即每个HTTP请求都会有各自的bean实例，它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

  <bean id="loginAction" class=cn.csdn.LoginAction" scope="request"/>

针对每次HTTP请求，Spring容器会根据loginAction bean的定义创建一个全新的LoginAction bean实例，且该loginAction bean实例仅在当前HTTP request内有效，因此可以根据需要放心的更改所建实例的内部状态，而其他请求中根据loginAction bean定义创建的实例，将不会看到这些特定于某个请求的状态变化。当处理请求结束，request作用域的bean实例将被销毁。

3.2、Session：
当一个bean的作用域为Session，表示在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

 <bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>

针对某个HTTP Session，Spring容器会根据userPreferences bean定义创建一个全新的userPreferences bean实例，且该userPreferences bean仅在当前HTTP Session内有效。与request作用域一样，可以根据需要放心的更改所创建实例的内部状态，而别的HTTP Session中根据userPreferences创建的实例，将不会看到这些特定于某个HTTP Session的状态变化。当HTTP Session最终被废弃的时候，在该HTTP Session作用域内的bean也会被废弃掉。

5、Bean的自动装配

5.1、手动配置如下

<bean id="dog" class="com.kuang.pojo.Dog"/>
<bean id="cat" class="com.kuang.pojo.Cat"/>
<bean id="user" class="com.kuang.pojo.User">
     <property name="cat" ref="cat"/>
     <property name="dog" ref="dog"/>
     <property name="str" value="张三"/>
</bean>

手动配置cat和dog有点麻烦，可以使用bean自动装配

5.2、byName

需要保证所有beanid唯一，并且这个bean需要和注入的属性的set方法值一致
会自动在上下文中查找，和自己对象set方法后面的值对应的beanid。例：setCat和cat
修改bean配置，增加一个属性 autowire="byName"

<bean id="user" class="com.kuang.pojo.User" autowire="byName">
     <property name="str" value="张三"/>
</bean>

5.3、byType

首先需要保证：同一类型的对象，在spring容器中唯一，否则会报不唯一的异常。
其次，需要在Spring中注册，没有id值也可以获取到

<bean id="user" class="com.kuang.pojo.User" autowire="byType">
      <property name="str" value="张三"/>
</bean>

6、使用注解开发

6.1、说明

jdk1.5开始支持注解，spring2.5开始全面支持注解。
在spring4之后，想要使用注解形式，必须得要引入aop的包
在配置文件当中，还得要引入一个context约束

<?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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
</beans>

6.2、Bean的实现

我们之前都是使用 bean 的标签进行bean注入，但是实际开发中，我们一般都会使用注解！
1、配置扫描哪些包下的注解

<!--指定注解扫描包-->
<context:component-scan base-package="com.kuang.pojo"/>

2、在指定包下编写类，增加注解

@Component("user")
// 相当于配置文件中 <bean id="user" class="当前注解的类"/>
public class User {
    public String name = "秦疆";
}

6.3、属性注入

使用注解注入属性
1、可以不用提供set方法，直接在直接名上添加@value("值")

@Value("秦疆")// 相当于配置文件中 <property name="name" value="秦疆"/>
public String name;

2、如果提供了set方法，在set方法上添加@value("值");

public String name;
@Value("秦疆")
public void setName(String name) {
     this.name = name;
}

6.4、衍生注解

为了更好的进行分层，Spring可以使用其它三个注解，功能一样,都是放在容器中注册。
@Component三个衍生注解:
@Controller：web层
@Service：service层
@Repository：dao层

6.5、自动装配注解（作用参考5）

1、@Autowired
@Autowired是按类型自动转配的，不支持id匹配，需要导入aop约束。
可以直接在属性上使用即可（可以没有Set方法）！也可以在set方式上使用！
@Autowired(required=false)说明：false，对象可以为null；true，对象必须存对象，不能为null。

2、@Qualifier
@Autowired是根据类型自动装配的，加上@Qualifier则可以根据byName的方式自动装配
@Qualifier不能单独使用。
例：

@Autowired
@Qualifier(value = "cat2")
private Cat cat;
@Autowired
@Qualifier(value = "dog2")
private Dog dog;

3、@Resource
指定一个name：自动装配

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

小结：@Resource和@Autowired的区别：
都是自动装配，可以放在属性字段上
@Autowired通过byType的方式实现，要求这个对象必须存在
@Resource如有指定的name属性，先按该属性进行byName方式查找装配；其次再进行默认的byName方式进行装配；如果以上都不成功，则按byType的方式自动装配。都不成功，则报异常。

6.6、作用域

@scope
singleton：默认的，Spring会采用单例模式创建这个对象。关闭工厂，所有的对象都会销毁。
prototype：多例模式。关闭工厂，所有的对象不会销毁。内部的垃圾回收机制会回收

@Scope("prototype")
public class User {
      public String name;
}

6.7、小结

XML与注解比较
XML可以适用任何场景，维护方便
注解不是自己提供的类使用不了，开发简单方便，维护相对复杂

xml与注解整合开发（推荐最佳实践）：
            xml管理Bean
            注解完成属性注入
            使用过程中，只需要注意一个问题：必须让注解生效就需要开启注解支持。可以不用扫描，扫描是为了类上的注解
        <context:annotation-config/> 作用：
            进行注解驱动注册，从而使注解生效
            用于激活那些已经在spring容器里注册过的bean上面的注解，也就是显示的向Spring注册
            如果不扫描包，就需要手动配置bean
            如果不加注解驱动，则注入的值为null！

7、基于Java类进行配置

JavaConfig 原来是 Spring 的一个子项目，它通过 Java 类的方式提供 Bean 的定义信息
在 Spring4 的版本， JavaConfig 已正式成为 Spring4 的核心功能。
1、实体类

public class Dog {
     public void shout(){
         System.out.println("wang");
     }
}

2、创建一个配置包config，创建一个配置类

@Configuration  //代表这是一个配置类
public class MyConfig {
      @Bean //通过方法注册一个bean，这里的返回值就Bean的类型，方法名就是bean的id！
      public Dog dog(){
           return new Dog();
      }
}

3、测试：

public static void main(String[] args){
        // 获取ApplicationContext，拿到配置包
            ApplicationContext context =new AnnotationConfigApplicationContext(MyConfig.class);
        //getBean获取对应id的bean
            Dog dog= context.getBean("dog", Dog.class);
            dog.shout();
}

多个配置类可以创建一个总类，在类名上使用@Import(MyConfig2.class)，导入合并其他配置类，类似于配置文件中的 inculde 标签
纯java的配置方式在SpringBoot中随处可见

8、代理模式

        为什么要学习代理模式，因为AOP的底层机制就是动态代理！
    代理模式：
        静态代理
        动态代理

8.1、静态代理：

静态代理角色分析
            抽象角色 : 一般使用接口或者抽象类来实现
            真实角色 : 被代理的角色
            代理角色 : 代理真实角色 ; 代理真实角色后 , 一般会做一些附属的操作
            客户 : 使用代理角色来进行一些操作。
静态代理的好处:
            可以使得我们的真实角色更加纯粹。不再去关注一些公共的事情。
            公共的业务由代理来完成。实现了业务的分工，公共业务发生扩展时变得更加集中和方便。
缺点 :
            类多了,多了代理类,工作量变大了。开发效率降低。
我们想要静态代理的好处，又不想要静态代理的缺点，所以就有了动态代理!

8.2、动态代理

动态代理的角色和静态代理的一样。
        动态代理的代理类是动态生成的。静态代理的代理类是我们提前写好的
动态代理分为两类 : 一类是基于接口动态代理 , 一类是基于类的动态代理
            基于接口的动态代理----JDK动态代理
            基于类的动态代理--cglib
            现在用的比较多的是 javasist 来生成动态代理 . 百度一下javasist
这里使用JDK的原生代码来实现，其余的道理都是一样的！
        1、编写一个通用的动态代理实现的类！所有的代理对象设置为Object：

import org.springframework.cglib.proxy.InvocationHandler;
import org.springframework.cglib.proxy.Proxy;
import java.lang.reflect.Method;
//动态代理工具类
public class ProxyInvocationHandler 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);
    }
    // proxy : 代理类
    // method : 代理类的调用处理程序的方法对象.
    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 methodName){
        System.out.println("执行了"+methodName+"方法");
    }
}

使用：

public static void main(String[] args) {
        //真实角色
        Host host = new Host();
        //代理实例的调用处理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(host); //将真实角色放置进去！
        //动态代理代理的是接口
        Rent proxy = (Rent)pih.getProxy(); //动态生成对应的代理类！
        proxy.rent();
    }

动态代理的好处
            静态代理有的它都有，静态代理没有的，它也有！
            可以使得我们的真实角色更加纯粹 . 不再去关注一些公共的事情 .
            公共的业务由代理来完成 . 实现了业务的分工 ,
            公共业务发生扩展时变得更加集中和方便 .
            一个动态代理 , 一般代理某一类业务
            一个动态代理可以代理多个类，代理的是接口！

9、AOP

9.1、准备工作导包：

导入包

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

9.2、使用Spring实现Aop

(1)、编写接口和实现类

public interface UserService {
    public void add();
    public void delete();
    public void update();
    public void select();

}
public class UserServiceImpl implements UserService{
    @Override
    public void add() {
        System.out.println("add");
    }
    @Override
    public void delete() {
        System.out.println("delete");
    }
    @Override
    public void update() {
        System.out.println("update");
    }
    @Override
    public void select() {
        System.out.println("select");
    }
}

(2)、编写前置增强类

public class log implements MethodBeforeAdvice {

    @Override
    public void before(Method method, Object[] objects, Object target) throws Throwable {
        System.out.println(target.getClass().getName()+"的"+ method.getName()+"方法执行了");
    }
}

(3)、去Spring中注册，并实现aop切入实现

<?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/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class="service.UserServiceImpl"/>
    <bean id="log" class="log.log"/>
    <!--aop的配置-->
    <aop:config>
        <!--切入点 expression:表达式匹配要执行的方法，execution(* service.UserServiceImpl.*(..))表示匹配service包下的UserServiceImpl类中的所有方法，(..)代表方法参数任意-->
        <aop:pointcut id="pointcut" expression="execution(* service.UserServiceImpl.*(..))"/>
        <!--执行环绕; advice-ref执行方法 . pointcut-ref切入点。将log方法加入到切入点中也就是UserServiceImpl类中的所有方法中-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
    </aop:config>
</beans>

(4)、测试

public class UserServiceImplTest {

    @Test
    public void add() {
    //ClassPathXmlApplicationContext获取spring中注册的bean
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml");
        //动态代理代理的是接口
        UserService userService =(UserService) context.getBean("userService");
        userService.add();
    }
}

输出：service.UserServiceImpl的add方法执行了

add

9.3、自定义类实现动态代理

(1)、编写接口和实现类，代码如上9.2

(2)、编写自定义类DiyPointCut

public class DiyPointCut {
    public void before(){
        System.out.println("before方法");
    }
    public void after(){
        System.out.println("after方法");
    }
}

(3)、配置文件

<?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/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class="service.UserServiceImpl"/>
    <!--方式二：自定义类-->
    <bean id="diy" class="diy.DiyPointCut"/>
    <aop:config>
        <!-- 自定义切面，ref要引用的类-->
        <aop:aspect ref="diy">
            <!-- 设置切入点-->
            <aop:pointcut id="diyPointCut" expression="execution(* service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before pointcut-ref="diyPointCut" method="before"/>
            <aop:after pointcut-ref="diyPointCut" method="after"/>
        </aop:aspect>
    </aop:config>

</beans>

(4)、测试

public class UserServiceImplTest {

     @Test
     public void add() {
         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans1.xml");
         //动态代理代理的是接口
         UserService userService =(UserService) context.getBean("userService");
         userService.add();
     }
 }

输出：before方法
add
after方法

9.4、注解实现

(1)、编写接口和实现类，代码如上9.2

(2)、编写一个注解实现的增强类

@Aspect//标注这个类是一个切面
public class AnnotationPointCut {
    @Before("execution(* service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("方法执行前");
    }
    @After("execution(* service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("方法执行后");
    }
    //环绕增强中可以给定一个参数，代表我们要获取处理切入的点
    @Around("execution(* service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("环绕前");
        jp.proceed();//执行代理类的方法
        System.out.println("环绕后");
    }
}

(3)、配置文件

<?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/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

    <bean id="userService" class="service.UserServiceImpl"/>
    <!--    方式三：注解实现-->
    <bean id="annotationPointCut" class="diy.AnnotationPointCut"/>
    <!--开启注解支持  JDK（默认，proxy-target-class="false"）cglib（proxy-target-class="true"）
    不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。两者没有区别
    -->
    <aop:aspectj-autoproxy proxy-target-class="false"></aop:aspectj-autoproxy>
</beans>

(4)、测试add方法，代码如上
            输出：
                环绕前
                方法执行前
                add
                环绕后
                方法执行后

10、整合mybatis

1、导入相关jar包

junit
<dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>4.12</version>
</dependency>

mybatis
<dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis</artifactId>
   <version>3.5.2</version>
</dependency>

mysql-connector-java
<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
   <version>5.1.47</version>
</dependency>

spring相关
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-webmvc</artifactId>
   <version>5.1.10.RELEASE</version>
</dependency>
<dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-jdbc</artifactId>
   <version>5.1.10.RELEASE</version>
</dependency>

aspectJ AOP 织入器
<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
   <groupId>org.aspectj</groupId>
   <artifactId>aspectjweaver</artifactId>
   <version>1.9.4</version>
</dependency>

mybatis-spring整合包 【重点】
<dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis-spring</artifactId>
   <version>2.0.2</version>
</dependency>

配置Maven静态资源过滤问题！
<build>
   <resources>
       <resource>
           <directory>src/main/java</directory>
           <includes>
               <include>**/*.properties</include>
               <include>**/*.xml</include>
           </includes>
           <filtering>true</filtering>
       </resource>
   </resources>
</build>

2、MyBatis-Spring

2.1、MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。

2.2、MyBatis-Spring 需要以下版本：
            MyBatis-Spring     MyBatis    Spring框架   Spring Batch   Java
            2.0                    3.5+       5.0+       4.0+           Java 8+
            1.3                    3.4+       3.2.2+      2.1+            Java 6+

2.3、如果使用 Maven 作为构建工具，仅需要在 pom.xml 中加入以下代码即可：

<dependency>
   <groupId>org.mybatis</groupId>
   <artifactId>mybatis-spring</artifactId>
   <version>2.0.2</version>
</dependency>

2.4、合并之前，我们有完整的dao层和service层
主要是通过spring-dao.xml具体配置替代mybatis-config核心配置文件

①、编写数据源配置，替代mybatis-config.xml中环境配置

<bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url"
                  value="jdbc:mysql://localhost:3306/mybatis?useSSL=false&amp;useUnicode=true&amp;characterEncoding=utf8"/>
    <property name="username" value="root"/>
    <property name="password" value="123456"/>
</bean>

②、sqlSessionFactory,内部可绑定mybatis配置文件

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
     <property name="dataSource" ref="datasource"/>
     <!--绑定mybatis配置文件-->
     <property name="configLocation" value="classpath:mybatis.xml"/>
     <!--mapper配置文件注册-->
     <property name="mapperLocations" value="classpath:mapper/*.xml"/>
 </bean>

③、sqlSessionTemplate，与②一起，创建出sqlSession对象，替代创建sqlSession工具类

<!--SqlSessionTemplate:就是我们使用的sqlSession-->
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
    <!--只能使用构造器注入sqlSessionFactory，因为没有set方法-->
    <constructor-arg index="0" ref="sqlSessionFactory"/>
</bean>

④、获取sqlSession:

方式一：编写接口实现类UserMapperImpl中定义一个私有属性SqlSessionTemplate sqlSession;

public class UserMapperImpl implements UserMapper {
   private SqlSessionTemplate sqlSession;
    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession = sqlSession;
    }
    @Override
    public List<User> query() {
        return sqlSession.getMapper(UserMapper.class).query();
    }
}

在spring中注册并给sqlSession赋值

<!--给类内sqlSession赋值，类内方法可直接通过sqlSession.getMapper获取接口对象，适用对象调用方法-->
<bean id="UserMapper" class="mapper.UserMapperImpl">
    <property name="sqlSession" ref="sqlSession"/>
</bean>

方式二：编写接口实现类UserMapperImpl继承SqlSessionDaoSupport，该父类可以直接使用getSqlSession获取sqlSession

public class UserMapperImpl extends SqlSessionDaoSupport implements UserMapper {
    @Override
    public List<User> query() {
        return getSqlSession().getMapper(UserMapper.class).query();
    }
}

在spring中注册，该方法可以省略③，SqlSessionDaoSupport类中需要给sqlSessionFactory赋值

<bean id="UserMapper" class="mapper.UserMapperImpl">
    <property name="sqlSessionFactory" ref="sqlSessionFactory"/>
</bean>

⑤、测试

@Test
public void query() {
    //ClassPathXmlApplicationContext用于获取spring配置文件中注册的bean
    ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-dao.xml");
    UserService userService =(UserService) context.getBean("UserService");
    userService.query();
}

11、Spring中的事务管理

Spring在不同的事务管理API之上定义了一个抽象层，使得开发人员不必了解底层的事务管理API就可以使用Spring的事务管理机制。Spring支持编程式事务管理和声明式的事务管理。

1、编程式事务管理
将事务管理代码嵌到业务方法中来控制事务的提交和回滚
缺点：必须在每个事务操作业务逻辑中包含额外的事务管理代码

2、声明式事务管理
        一般情况下比编程式事务好用。
        将事务管理代码从业务方法中分离出来，以声明的方式来实现事务管理。
        将事务管理作为横切关注点，通过aop方法模块化。Spring中通过Spring AOP框架支持声明式事务管理。

3、Spring声明事务

3.1、导入aop和tx约束

xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd

3.2、配置声明事务

<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
     <property name="dataSource" ref="datasource"/>
</bean>

3.3、结合AOP实现事务的织入

<!--配置事务通知：-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
 <!--给哪些方法配置事务-->
 <!--配置事务的传播特性：propagation="REQUIRED"（默认）-->
 <!--    requierd：如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。
         supports：支持当前事务，如果没有当前事务，就以非事务方法执行。
         mandatory：使用当前事务，如果没有当前事务，就抛出异常。
         required_new：新建事务，如果当前存在事务，把当前事务挂起。
         not_supported：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
         never：以非事务方式执行操作，如果当前事务存在则抛出异常。
         nested：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与propagation_required类似的操作
 -->
 <tx:attributes>
      <!--设置哪些方法有事务-->
     <tx:method name="addUser" propagation="REQUIRED"/>
     <tx:method name="deleteUser" propagation="REQUIRED"/>
     <tx:method name="queryUsers" read-only="true"/>
 </tx:attributes>
</tx:advice>

3.4、配置事务切入

 <aop:config>
     <aop:pointcut id="txPointCut" expression="execution(* mapper.*.*(..))"/>
     <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
 </aop:config>