Java Spring学习笔记

Java Spring学习笔记

【狂神说Java】Spring5学习笔记

1、Spring概述

1.1 简介

• 网站：.html#beans-factory-scopes

• spring理念：使现有的技术更加简单，整合了现有的技术框架。

• SSH：Struct2 + Spring + Hibernate

• SSM：SpringMVC + Spring + Mybatis

• 导包 (maven)：

  <!-- .springframework/spring-webmvc -->
  <dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.3.5</version>
  </dependency><!-- .springframework/spring-jdbc -->
  <dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.3.5</version>
  </dependency>
  

1.2 优点

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

1.3 组成

• 核心容器（Spring Core）

核心容器提供Spring框架的基本功能。Spring以bean的方式组织和管理Java应用中的各个组件及其关系。Spring使用BeanFactory来产生和管理Bean，它是工厂模式的实现。BeanFactory使用控制反转(IoC)模式将应用的配置和依赖性规范与实际的应用程序代码分开。

• 应用上下文（Spring Context）

Spring上下文是一个配置文件，向Spring框架提供上下文信息。Spring上下文包括企业服务，如JNDI、EJB、电子邮件、国际化、校验和调度功能。

• Spring面向切面编程（Spring AOP）

通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring框架中。所以，可以很容易地使 Spring框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。

• JDBC和DAO模块（Spring DAO）

JDBC、DAO的抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理，和不同数据库供应商所抛出的错误信息。异常层次结构简化了错误处理，并且极大的降低了需要编写的代码数量，比如打开和关闭链接。

• 对象实体映射（Spring ORM）

Spring框架插入了若干个ORM框架，从而提供了ORM对象的关系工具，其中包括了Hibernate、JDO和 IBatis SQL Map等，所有这些都遵从Spring的通用事物和DAO异常层次结构。

• Web模块（Spring Web）

Web上下文模块建立在应用程序上下文模块之上，为基于web的应用程序提供了上下文。所以Spring框架支持与Struts集成，web模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

• MVC模块（Spring Web MVC）

MVC框架是一个全功能的构建Web应用程序的MVC实现。通过策略接口，MVC框架变成为高度可配置的。MVC容纳了大量视图技术，其中包括JSP、POI等，模型来有JavaBean来构成，存放于m当中，而视图是一个街口，负责实现模型，控制器表示逻辑代码，由c的事情。Spring框架的功能可以用在任何J2EE服务器当中，大多数功能也适用于不受管理的环境。Spring的核心要点就是支持不绑定到特定J2EE服务的可重用业务和数据的访问的对象，毫无疑问这样的对象可以在不同的J2EE环境，独立应用程序和测试环境之间重用。

2、IOC理论推导及本质 ★★★

• 用户的需求可能会影响本身的代码，我们需要根据用户的需求去修改源代码！如果代码量十分大，修改一次的代价十分昂贵！

• 本质：

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

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

• 如：

• IOC：对象由Spring创建、管理、装配！

3、HelloSpring

• Hello实体类

  package com.zhangyc.pojo;public class Hello {private String str;public Hello(String str) {this.str = str;}public Hello() {}public String getStr() {return str;}public void setStr(String str) {this.str = str;}@Overridepublic String toString() {return "Hello{" +"str='" + str + ''' +'}';}
  }
  

• <?xml version="1.0" encoding="UTF-8"?>
  <beans xmlns=""xmlns:xsi=""xsi:schemaLocation=" .xsd"><!--使用spring来创建对象，在spring中都成为Bean类型 变量名 = new 类型();Hello hello = new Hello();id = 变量名class = new 的对象property 相当于给对象中的属性赋值！--><bean id="hello" class="com.zhangyc.pojo.Hello"><property name="str" value="Spring"/></bean></beans>
  

• test

  import com.zhangyc.pojo.Hello;
  import t.ApplicationContext;
  import t.support.ClassPathXmlApplicationContext;public class MyTest {public static void main(String[] args) {// 获取Spring的上下文对象！ApplicationContext context = new ClassPathXmlApplicationContext(&#l");// 我们的对象现在都在Spring中管理，使用时直接取出来就可以了！Hello hello = Bean("hello", Hello.class);
  //        Hello hello = (Hello) Bean("hello");System.out.String());}
  }
  

• 注意

  这个过程就叫做控制反转！

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

4、IOC创建对象方式

• 无参构造方法创建Bean对象，默认

  <bean id="user" class="com.zhangyc.pojo.User"><property name="name" value="张三"/>
  </bean>
  

• 有参构造方法创建Bean对象

  • 方式一：下标赋值

    <bean id="user" class="com.zhangyc.pojo.User"><constructor-arg index="0" value="李四"/>
    </bean>
    

  • 方式二：类型赋值（不建议使用，假如有多种String变量，无法确定）

    <bean id="user" class="com.zhangyc.pojo.User"><constructor-arg type="java.lang.String" value="李四"/>
    </bean>
    

  • 方式三：参数名赋值

    <bean id="user" class="com.zhangyc.pojo.User"><constructor-arg name="name" value="李四"/>
    </bean>
    

• 总结：在配置文件加载的时候，容器中管理的对象就已经初始化了，无论是否调用！

5、Spring配置

5.1 别名

• xml中配置：

  <!--别名-->
  <alias name="user" alias="别名"/>
  

• 使用时：

  ApplicationContext context = new ClassPathXmlApplicationContext(&#l");
  User user = (User) Bean("别名");
  user.show();
  

5.2 Bean的配置

<bean id="user" class="com.zhangyc.pojo.User" name="user1, user2">  <!--name 也是别名，而且可以赋值多个--><property name="name" value="张三"/>
</bean>

5.3 import

• 一般用于团队开发使用，将多个配置文件，合并成一个

6、DI（依赖注入）★★★

6.1 构造器注入

• 前面的方式就是构造器注入

6.2 Set方式注入（重点）

• 依赖注入：本质是Set注入

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

• xml：

  <?xml version="1.0" encoding="UTF-8"?>
  <beans xmlns=""xmlns:xsi=""xsi:schemaLocation=" .xsd"><bean id="address" class="com.zhangyc.pojo.Address"><property name="address" value="重庆"/></bean><bean id="student" class="com.zhangyc.pojo.Student"><!--方式一：普通值注入，直接使用value--><property name="name" value="张三"/><!--方式二：bean注入，ref--><property name="address" ref="address"/><!--方式三：数组注入--><property name="books"><array><value>红楼梦</value><value>西游记</value><value>水浒传</value></array></property><!--方式四：List注入--><property name="hobbies"><list><value>听歌</value><value>睡大觉</value><value>敲代码</value></list></property><!--方式五：Map注入--><property name="card"><map><entry key="身份证" value="132456"/><entry key="银行卡" value="541263"/></map></property><!--方式六：Set注入--><property name="games"><set><value>LOL</value><value>CS</value></set></property><!--方式七：null注入--><property name="wife"><null/></property><!--方式八：Properties注入--><property name="info"><props><prop key="学号">S190301048</prop><prop key="性别">男</prop><prop key="姓名">阿巴阿巴</prop></props></property></bean>
  </beans>
  

• 结果：

  Student{name='张三', address=Address{address='重庆'}, books=[红楼梦, 西游记, 水浒传], hobbies=[听歌, 睡大觉, 敲代码], card={身份证=132456, 银行卡=541263}, games=[LOL, CS], info={姓名=阿巴阿巴, 学号=S190301048, 性别=男}, wife='null'}
  

6.3 拓展方式注入

• p命名空间注入（set注入）

• c命名空间注入（构造器注入，需要有参构造）

6.4 bean的作用域

• 单例模式（singleton）：若重复get同一个对象，只会新建一个新的对象
• 原型模式（prototype）：每次从容器中get的时候，都会生成一个新的对象

7、Bean的自动装配

• 自动装配是Spring满足bean依赖的一种方式！
• Spring会在上下文中自动寻找，并自动给bean装配属性！
• Spring由三种装配方式
  • 在xml显示的配置
  • 在java中显示的配置
  • 隐式的自动装配bean（重要）

7.1 ByName自动装配

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

7.2 ByType自动装配

<bean class="com.zhangyc.pojo.Cat"/>
<bean class="com.zhangyc.pojo.Dog"/>
<!--byType：会自动在容器上下文中查找和自己对象属性类型相同的bean id！
-->
<bean id="people" class="com.zhangyc.pojo.People" autowire="byType"><property name="name" value="张三"/>
</bean>

7.3 小结

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

7.4 注解自动装配 ★

• 使用注解须知：

  • 导入约束：context

  • 配置注解的支持

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns=""xmlns:xsi=""xmlns:context=""xsi:schemaLocation="://www.springframework/schema/beans/spring-beans.xsd://www.springframework/schema/context/spring-context.xsd"><context:annotation-config/><bean id="cat" class="com.zhangyc.pojo.Cat"/><bean id="dog" class="com.zhangyc.pojo.Dog"/><bean id="people" class="com.zhangyc.pojo.People"/></beans>
    

  • 调用

    package com.zhangyc.pojo;import org.springframework.beans.factory.annotation.Autowired;public class People {@Autowiredprivate Cat cat;@Autowiredprivate Dog dog;private String name;...
    }
    

    也可以在set方法上使用。

  • 使用autowired时，cat和dog中的setter方法都不需要了，前提是这个自动装配的属性在IOC容器中存在，且名字符合。

  • required=false

• 补充1：

• 补充2：

• 补充3：

  • @Autowired 默认使用bytype，不匹配则使用byname
  • @Resource 默认使用byname，不匹配则使用bytype

8、注解开发 ★

注：在Spring4以后，使用注解开发必须导入AOP

• bean

  // 等价于 <bean id="user" class="com.zhangyc.pojo.User"/>
  // 使用时，bean的名字默认是User的小写
  // User user = Bean("user", User.class);
  @Component
  public class User {public String name = "张三";
  }
  

• 属性如何注入

      /** 方式一：* 等价于 <property name="name" value="张三"/>*/@Value("张三")public String name;//    // 方式二：
  //    @Value("张三")
  //    public void setName(String name) {
  //        this.name = name;
  //    }
  

• 衍生的注解

  • @Component有几个衍生注解，在web开发中，会按照mvc三层架构分层

    • dao：@Repository
    • service：@Service
    • controller：@Controller

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

• 自动装配

• 作用域

  @Scope("singleton")
  public class User {public String name = "张三";
  }
  

  • 单例模式
  • 原型模式

• 小结

  • xml与注解：

    • xml更加万能，适用于任何场合，维护简单！
    • 注解只能用于自己的类，维护相对复杂！

  • xml与注解最佳实践：

    • xml用来管理bean

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

    • 使用过程中，只需要注意一个问题：必须让注解生效

      <!--指定要扫描的包，这个包下的注解就会生效-->
      <context:component-scan base-package="com.zhangyc"/>
      <context:annotation-config/>
      

9、JavaConfig配置Spring

• 不使用Spring的xml配置，全权交给java来做！

• 实体类

  package com.zhangyc.pojo;
  import org.springframework.beans.factory.annotation.Value;public class User {private String name;public String getName() {return name;}@Value("张三")public void setName(String name) {this.name = name;}@Overridepublic String toString() {return "User{" +"name='" + name + ''' +'}';}
  }
  

• 配置类：

  package fig;import com.zhangyc.pojo.User;
  import t.annotation.Bean;
  import t.annotation.ComponentScan;
  import t.annotation.Configuration;// @Configuration：配置类，等价于 l
  @Configuration
  // @ComponentScan: 显示声明扫描包，也可以省略
  @ComponentScan("com.zhangyc.pojo")
  public class MyConfig {/*** 注册一个bean* 方法的名字 == bean标签中的id* 方法的返回值 == bean标签中的class* @return 返回值就是要注入到bean的对象*/@Beanpublic User getUser() {return new User();}
  }
  

• 测试时：

  import fig.MyConfig;
  import com.zhangyc.pojo.User;
  import org.junit.Test;
  import t.ApplicationContext;
  import t.annotation.AnnotationConfigApplicationContext;public class MyTest {@Testpublic void test() {ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);User user = Bean("getUser", User.class);System.out.Name());}
  }
  

10、代理模式 ★

10.1 代理模式的分类：

• 静态代理
• 动态代理
• 例子：

10.2 静态代理

角色分析：

• 抽象角色：一般会使用接口或抽象类

• 真实角色：被代理的角色

• 代理角色：代理真实角色，代理真实角色后一般会做一些附属操作

• 客户：访问代理对象的人

• 演示

好处与缺点：

10.3 聊聊AOP

10.4 动态代理

• 动态代理和静态代理的角色一样
• 动态代理的代理类是动态生成的
• 动态代理分为两类：基于接口的动态代理和基于类的动态代理
  • 基于接口：JDK动态代理（★）
  • 基于类：cglib
  • java字节码：javassist
• 需要了解两个类：Proxy（代理）和 InvocationHandler（调用处理程序）

// 自动生成代理类
public class ProxyInvocationHandler implements InvocationHandler {// 被代理的接口private Object object;public void setObject(Object object) {this.object = object;}// 生成得到代理类public Object getProxy() {Class().getClassLoader(), Class().getInterfaces(), this);}// 处理代理实例，并返回结果@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {// 也可以自己添加一些附加方法，比如日志等Name());// 动态代理的本质，就是使用反射机制实现！return method.invoke(object, args);}public void log(String msg) {System.out.println("[Debug] : " + msg + "() is running !");}
}

11、AOP ★★★

11.1 AOP概述

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

11.2 AOP在Spring中的作用

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

以下名词需要了解下：

• 横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
• 切面（ASPECT）：横切关注点 被模块化 的特殊对象。即，它是一个类。
• 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
• 目标（Target）：被通知对象。
• 代理（Proxy）：向目标对象应用通知之后创建的对象。
• 切入点（PointCut）：切面通知 执行的 “地点”的定义。
• 连接点（JointPoint）：与切入点匹配的执行点。

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

即 Aop 在 不改变原有代码的情况下 , 去增加新的功能。

11.3 使用Spring实现AOP

注意：需要导包！

<!--AOP-->
<dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.6</version>
</dependency>

11.3.1 方式一：使用Spring的API接口

• UserService接口

  package com.zhangyc.service;public interface UserService {public void add();public void delete();public void update();public void select();
  }
  

• UserServiceImpl实现类

  package com.zhangyc.service;public class UserServiceImpl implements UserService {@Overridepublic void add() {System.out.println("增加了一个用户!");}@Overridepublic void delete() {System.out.println("删除了一个用户!");}@Overridepublic void update() {System.out.println("更新了一个用户!");}@Overridepublic void select() {System.out.println("查询了一个用户!");}
  }
  

• 编写增强类

  • AfterLog

    package com.zhangyc.log;import org.springframework.aop.AfterReturningAdvice;import flect.Method;public class AfterLog implements AfterReturningAdvice {/**** @param o 返回值* @param method 要执行的目标对象的方法* @param objects 参数* @param o1 目标对象* @throws Throwable*/@Overridepublic void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {System.out.println("执行了" + Name() + "方法，返回结果为：" + o);}
    }
    

  • BeforeLog

    package com.zhangyc.log;import org.springframework.aop.MethodBeforeAdvice;import flect.Method;public class BeforeLog implements MethodBeforeAdvice {/**** @param method 要执行的目标对象的方法* @param objects 参数* @param o 目标对象* @throws Throwable*/@Overridepublic void before(Method method, Object[] objects, Object o) throws Throwable {assert o != null;System.out.Class().getName() + "的" + Name() + "方法被执行了！");}
    }
    

• <?xml version="1.0" encoding="UTF-8"?>
  <beans xmlns=""xmlns:xsi=""xmlns:aop=""xsi:schemaLocation=" .xsd .xsd"><!--注册bean--><bean id="userService" class="com.zhangyc.service.UserServiceImpl"/><bean id="beforeLog" class="com.zhangyc.log.BeforeLog"/><bean id="afterLog" class="com.zhangyc.log.AfterLog"/><!--配置AOP--><!--方式一：使用原生Spring接口--><aop:config><!--切入点: execution(): 要执行的位置--><aop:pointcut id="pointcut" expression="execution(* com.zhangyc.service.UserServiceImpl.*(..))"/><!--执行环绕增强--><aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/><aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/></aop:config>
  </beans>
  

• test

  import com.zhangyc.service.UserService;
  import t.ApplicationContext;
  import t.support.ClassPathXmlApplicationContext;public class MyTest {public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext(&#l");// 注意：动态代理代理的是接口UserService userService = Bean("userService", UserService.class);userService.select();}
  }
  

11.3.2 方式二：自定义类【切面】

• 自定义插入类：DiyPointCut

  package com.zhangyc.diy;public class DiyPointCut {public void before() {System.out.println("========================== 方法执行前 ==========================");}public void after() {System.out.println("========================== 方法执行后 ==========================");}
  }
  

• <!--方式二：自定义类-->
  <bean id="diy" class="com.zhangyc.diy.DiyPointCut"/><aop:config><!--切入面--><aop:aspect ref="diy"><!--切入点--><aop:pointcut id="point" expression="execution(* com.zhangyc.service.UserServiceImpl.*(..))"/><!--通知--><aop:before method="before" pointcut-ref="point"/><aop:after method="after" pointcut-ref="point"/></aop:aspect>
  </aop:config>
  

11.3.3 方式三：注解实现

• 编写注解插入类：AnnotationPointCut

  package com.zhangyc.diy;import org.aspectj.lang.ProceedingJoinPoint;
  import org.aspectj.lang.annotation.After;
  import org.aspectj.lang.annotation.Around;
  import org.aspectj.lang.annotation.Aspect;
  import org.aspectj.lang.annotation.Before;// 方式三：注解实现AOP
  @Aspect // 标注这是一个切面
  public class AnnotationPointCut {@Before("execution(* com.zhangyc.service.UserServiceImpl.*(..))")public void before() {System.out.println("========================== 方法执行前 ==========================");}@After("execution(* com.zhangyc.service.UserServiceImpl.*(..))")public void after() {System.out.println("========================== 方法执行后 ==========================");}// 在环绕增强中，可以设定一个参数，代表要获取处理切入的点@Around("execution(* com.zhangyc.service.UserServiceImpl.*(..))")public void around(ProceedingJoinPoint joinPoint) throws Throwable {System.out.println("环绕前");//执行方法Object proceed = joinPoint.proceed();System.out.println("环绕后");System.out.println(proceed);}
  }
  

• <!--方式三：使用注解实现AOP-->
  <bean id="annotationPointCut" class="com.zhangyc.diy.AnnotationPointCut"/>
  <!--开启注解支持-->
  <aop:aspectj-autoproxy/>
  

12、整合Mybatis

12.1 回忆Mybatis

• 编写实体类

  package com.zhangyc.pojo;import lombok.Data;@Data
  public class User {private int id;private String name;private String pwd;
  }
  

• 编写核心配置文件

  <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE configurationPUBLIC "-//mybatis//DTD Config 3.0//EN"".dtd"><configuration><typeAliases><package name="com.zhangyc.pojo"/></typeAliases><!--通过Spring配置数据源 l--><environments default="development"><environment id="development"><transactionManager type="JDBC"/><dataSource type="POOLED"><property name="driver" value=&#sql.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;userUnicode=true&amp;characterEncoding=UTF-8"/><property name="username" value="root"/><property name="password" value="012400"/></dataSource></environment></environments><mappers><!-- 绑定xml --><mapper resource="l"/></mappers>
  </configuration>
  

• 编写接口

  package com.zhangyc.mapper;import com.zhangyc.pojo.User;import java.util.List;public interface UserMapper {List<User> selectUser();
  }
  

• 编写l

  <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE mapperPUBLIC "-//mybatis//DTD Config 3.0//EN"".dtd"><mapper namespace="com.zhangyc.mapper.UserMapper"><select id="selectUser" resultType="user">select * from mybatis.user;</select></mapper>
  

• 测试

  @Test
  public void test() throws IOException {InputStream inputStream = ResourceAsStream(&#l");SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);SqlSession sqlSession = sessionFactory.openSession(true);UserMapper mapper = Mapper(UserMapper.class);List<User> users = mapper.selectUser();users.forEach(System.out::println);
  }
  

12.2 Mybatis-spring

• 导入依赖

  <!--Spring-->
  <dependency><groupId>org.springframework</groupId><artifactId>spring-webmvc</artifactId><version>5.3.5</version>
  </dependency><!--数据库驱动-->
  <dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>5.1.49</version>
  </dependency><!--Spring操作数据库-->
  <dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.3.5</version>
  </dependency><!--Mybatis-->
  <dependency><groupId&batis</groupId><artifactId>mybatis</artifactId><version>3.5.2</version>
  </dependency><dependency><groupId&batis</groupId><artifactId>mybatis-spring</artifactId><version>2.0.6</version>
  </dependency><!--lombok-->
  <dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><version>1.18.16</version>
  </dependency><!--AOP-->
  <dependency><groupId>org.aspectj</groupId><artifactId>aspectjweaver</artifactId><version>1.9.6</version>
  </dependency>
  

• 编写数据源

• sqlSessionFactory

• sqlSessionTemplate

• 需要给接口加实现类

• 将自己写的实现类注入Spring中

• 测试

12.2.1 方式一

• 修改l

  <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE configurationPUBLIC "-//mybatis//DTD Config 3.0//EN"".dtd"><configuration><typeAliases><package name="com.zhangyc.pojo"/></typeAliases></configuration>
  

• 配置l

  <?xml version="1.0" encoding="UTF-8"?>
  <beans xmlns=""xmlns:xsi=""xsi:schemaLocation=" .xsd"><!--DataSource: 使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid--><bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"><property name="driverClassName" value=&#sql.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;userUnicode=true&amp;characterEncoding=UTF-8"/><property name="username" value="root"/><property name="password" value="012400"/></bean><!--sqlSessionFactory--><bean id="sqlSessionFactory" class=&#batis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="datasource"/><!--绑定Mybatis配置文件--><property name="configLocation" value="l"/><property name="mapperLocations" value="classpath:l"/></bean><!--sqlSessionTemplate--><bean id="sqlSessionTemplate" class=&#batis.spring.SqlSessionTemplate"><!--只能使用构造器注入sqlSessionFactory，因此它没有set方法--><constructor-arg index="0" ref="sqlSessionFactory"/></bean></beans>
  

• 编写UserMapperImpl实现类

  package com.zhangyc.mapper;import com.zhangyc.pojo.User;
  batis.spring.SqlSessionTemplate;import java.util.List;// 方式一
  public class UserMapperImpl implements UserMapper {// 使用sqlSessionTemplateprivate SqlSessionTemplate sqlSessionTemplate;public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {this.sqlSessionTemplate = sqlSessionTemplate;}public List<User> selectUser() {UserMapper mapper = Mapper(UserMapper.class);return mapper.selectUser();}
  }
  

• 配置l

  <?xml version="1.0" encoding="UTF-8"?>
  <beans xmlns=""xmlns:xsi=""xsi:schemaLocation=" .xsd"><import resource=&#l"/><!--方式一--><bean id="userMapperImpl" class="com.zhangyc.mapper.UserMapperImpl"><property name="sqlSessionTemplate" ref="sqlSessionTemplate"/></bean></beans>
  

• test

  @Test
  public void testSpringMybatis() {ApplicationContext context = new ClassPathXmlApplicationContext(&#l");UserMapper userMapper = Bean("userMapperImpl", UserMapper.class);List<User> users = userMapper.selectUser();users.forEach(System.out::println);
  }
  

12.2.2 方式二

• UserMapperImpl2实现类

  package com.zhangyc.mapper;import com.zhangyc.pojo.User;
  import org.apache.ibatis.session.SqlSession;
  batis.spring.support.SqlSessionDaoSupport;import java.util.List;// 方法二：不需要自己再配置l中的sqlSessionTemplate
  public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{@Overridepublic List<User> selectUser() {return getSqlSession().getMapper(UserMapper.class).selectUser();}
  }
  

• 配置l

  <?xml version="1.0" encoding="UTF-8"?>
  <beans xmlns=""xmlns:xsi=""xsi:schemaLocation=" .xsd"><import resource=&#l"/><!--方式二--><bean id="userMapperImpl2" class="com.zhangyc.mapper.UserMapperImpl2"><property name="sqlSessionFactory" ref="sqlSessionFactory"/></bean></beans>
  

• test

  @Test
  public void testSpringMybatis2() {ApplicationContext context = new ClassPathXmlApplicationContext(&#l");UserMapper userMapper = Bean("userMapperImpl2", UserMapper.class);List<User> users = userMapper.selectUser();users.forEach(System.out::println);
  }
  

13、声明式事务

• 声明式事务：AOP

  • 编写实体类

    package com.zhangyc.pojo;import lombok.AllArgsConstructor;
    import lombok.Data;
    import lombok.NoArgsConstructor;@Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class User {private int id;private String name;private String pwd;
    }
    

  • 配置l

  <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE configurationPUBLIC "-//mybatis//DTD Config 3.0//EN"".dtd"><configuration><typeAliases><package name="com.zhangyc.pojo"/></typeAliases></configuration>
  

  • 编写接口

    package com.zhangyc.mapper;import com.zhangyc.pojo.User;import java.util.List;public interface UserMapper {List<User> selectUser();public int addUser(User user);public int deleteUser(int id);
    }
    

  • 配置l

  <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE mapperPUBLIC "-//mybatis//DTD Config 3.0//EN"".dtd"><mapper namespace="com.zhangyc.mapper.UserMapper"><select id="selectUser" resultType="user">select * from mybatis.user;</select><insert id="addUser" parameterType="user">insert into mybatis.user (id, name, pwd)values (#{id}, #{name}, #{pwd});</insert><delete id="deleteUser" parameterType="int">delete from mybatis.user where id=#{id};</delete></mapper>
  

  • 编写接口实现类

    package com.zhangyc.mapper;import com.zhangyc.pojo.User;
    batis.spring.support.SqlSessionDaoSupport;import java.util.List;// 方法二：不需要自己再配置sqlSessionTemplate
    public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{@Overridepublic List<User> selectUser() {// 测试事务User user = new User(7, "pizzazz", "45454");UserMapper mapper = getSqlSession().getMapper(UserMapper.class);mapper.addUser(user);mapper.deleteUser(7);return mapper.selectUser();}@Overridepublic int addUser(User user) {return getSqlSession().getMapper(UserMapper.class).addUser(user);}@Overridepublic int deleteUser(int id) {return getSqlSession().getMapper(UserMapper.class).deleteUser(id);}
    }
    

  • 配置l

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns=""xmlns:xsi=""xmlns:tx=""xmlns:aop=""xsi:schemaLocation=" .xsd .xsd .xsd"><!--DataSource: 使用Spring的数据源替换Mybatis的配置 c3p0 dbcp druid--><bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"><property name="driverClassName" value=&#sql.jdbc.Driver"/><property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;userUnicode=true&amp;characterEncoding=UTF-8"/><property name="username" value="root"/><property name="password" value="012400"/></bean><!--sqlSessionFactory--><bean id="sqlSessionFactory" class=&#batis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="datasource"/><!--绑定Mybatis配置文件--><property name="configLocation" value="l"/><property name="mapperLocations" value="classpath:l"/></bean><!--配置声明式事务--><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><constructor-arg ref="datasource"/></bean><!--结合AOP实现事务的织入--><!--配置事务通知--><tx:advice id="txAdvice" transaction-manager="transactionManager"><!--给方法配置事务和传播特性--><tx:attributes><tx:method name="add" propagation="REQUIRED"/>  <!--propagation="REQUIRED" 默认--><tx:method name="delete"/><tx:method name="update"/><tx:method name="select" read-only="true"/><tx:method name="*"/></tx:attributes></tx:advice><!--配置事务切入--><aop:config><aop:pointcut id="txPointCut" expression="execution(* com.zhangyc.mapper.*.*(..))"/><aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/></aop:config></beans>
    

  • 配置l

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns=""xmlns:xsi=""xsi:schemaLocation=" .xsd"><import resource=&#l"/><!--方式二--><bean id="userMapperImpl2" class="com.zhangyc.mapper.UserMapperImpl2"><property name="sqlSessionFactory" ref="sqlSessionFactory"/></bean></beans>
    

  • test

    import com.zhangyc.mapper.UserMapper;
    import com.zhangyc.pojo.User;
    import org.junit.Test;
    import t.ApplicationContext;
    import t.support.ClassPathXmlApplicationContext;import java.util.List;public class MyTest {@Testpublic void testSpringMybatis2() {ApplicationContext context = new ClassPathXmlApplicationContext(&#l");UserMapper userMapper = Bean("userMapperImpl2", UserMapper.class);List<User> users = userMapper.selectUser();users.forEach(System.out::println);}
    }
    

• 编程式事务：事务管理