Spring---狂神说Java学习笔记
Spring
哔哩哔哩狂神说Java-Spring学习网址
文章只为分享学习经验和自己复习用，学习还是该去查看正规视频网站和官方文档才更有效
文章目录
- Spring
-
- 1、简介
-
- 1.1、优点
- 1.2、组成
- 1.3、拓展
- 2、IOC理论推导
-
- 2.1、IOC基础
-
- 1、分析实现
- 2、修改后
- 2.2、IOC本质
- 2.3、HelloSpring
- 2.4、修改之前的代码
- 2.5、IOC创建对象的方式---构造器注入
- 3、Spring的基础配置
-
- 3.1、别名 alias
- 3.2、Bean的配置
- 3.3、import
- 4、DI 依赖注入
-
- 4.1、构造器注入
- 4.2、set方式注入 【重点】
- 4.3、p 、c 标签注入
- 4.4、Bean的作用域
- 5、Bean的自动装配
-
- 5.1、autowire---ByName与ByType自动装配
- 5.2、使用注解实现自动装配
- 5.3、@Autowired与@Resource
-
- 1、@Autowired
- 2、@Resource
- 6、使用注解开发
- 7、使用Java的方式配置Spring
- 8、代理模式
-
- 8.1、静态代理
- 8.2、动态代理
-
- 1、普通方法测试
- 2、抽象方法测试
- 3、动态代理的好处
- 9、AOP
-
- 9.1、什么是AOP
- 9.2、Aop在Spring中的作用
- 9.3、使用Spring实现Aop
-
- 方式一：使用Spring的API接口
- 方式二：自定义来实现AOP
- 方式三：使用注解实现AOP
- 10、整合Mybatis
-
- 10.1、回忆mybatis
- 10.2、MyBatis-Spring
- 10.3、SqlSessionDaoSupport 再进行简化
- 11、声明式事务
-
- 1、回顾事务
- 2、事务流程回顾
- 3、Srting中的事务管理
1、简介
Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。
- Spring：春天-------->给软件行业带来了春天！
- 2002，首次推出了Spring框架的雏形：interface21框架
- 2004年3月24日， Sping框架发布了1.0正式版，即以interface21框架为基础，经过重新设计，并不断丰富其内涵。
- Rod Johnson，Spring Framework创始人，著名作者。很难想象 Rod Johnson 的学历，真的让好多人大吃一惊，他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学
- “轮子理论” 即 “不要重复发明轮子”
- Spring 的理念：使现有的技术更加容易适用，本身是一个 ”大杂烩“，整合了现有的技术框架
- SSH：Struct2 + Spring + Hibernate
- SSM：SpringMav + Spring + Mybatis
官网：https://spring.io/projects/spring-framework
官方下载地址：https://repo.spring.io/ui/native/release/org/springframework/spring
GitHub :https://github.com/spring-projects/spring-framework
官方文档：https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-basics
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webmvcartifactId>
<version>5.3.10version>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-jdbcartifactId>
<version>5.3.10version>
dependency>
1.1、优点
- Spring是一个开源免费的框架 , 容器
- Spring是一个轻量级的，非入侵式的框架
- 两大重点：控制反转 （IOC），面向切面 （AOP）
- 支持事务的处理， 对框架整合的支持
总结一句话：Spring是一个轻量级的控制反转 ( IOC ) 和 面向切面 ( AOP ) 的容器（框架）
1.2、组成
Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式 .
组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：
核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖组件，就可以将声明性事务管理集成到应用程序中。
Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。
1.3、拓展
Spring Boot与Spring Cloud
-
Spring Boot
- 是 Spring 的一套快速配置脚手架
- 可以基于Spring Boot 快速开发单个微服务
- 约定大于配置
-
Spring Cloud
- 是基于Spring Boot实现的
因为现在大多数公司都在适用SpringBooy进行快速开发，学习SpringBoot的前提，需要完全掌控Spring及SpringMVC，承上启下的作用
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基础
新建一个空白的maven项目
导入包
父类pom.xml
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webmvcartifactId>
<version>5.3.10version>
dependency>
1、分析实现
我们先用我们原来的方式写一段代码 .
1、先写一个UserDao接口
public interface UserDao {
public void getUser();
}
2、再去写Dao的实现类
public class UserDaoImpl implements UserDao {
@Override
public void getUser() {
System.out.println("默认获取用户数据");
}
}
3、然后去写UserService的接口
public interface UserService {
public void getUser();
}
4、最后写Service的实现类
public class UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoImpl();
@Override
public void getUser() {
userDao.getUser();
}
}
5、测试一下
@Test
public void test(){
UserService service = new UserServiceImpl();
service.getUser();
}
这是我们原来的方式 , 开始大家也都是这么去写的对吧 . 那我们现在修改一下 .
2、修改后
把Userdao的实现类增加一个
public class UserDaoMySqlImpl implements UserDao {
@Override
public void getUser() {
System.out.println("MySql获取用户数据");
}
}
紧接着我们要去使用MySql的话 , 我们就需要去service实现类里面修改对应的实现
public class UserServiceImpl implements UserService {
private UserDao userDao = new UserDaoMySqlImpl();
@Override
public void getUser() {
userDao.getUser();
}
}
在假设, 我们再增加一个Userdao的实现类 .
public class UserDaoOracleImpl implements UserDao {
@Override
public void getUser() {
System.out.println("Oracle获取用户数据");
}
}
那么我们要使用Oracle , 又需要去service实现类里面修改对应的实现。
这种方式就根本不适用, 甚至反人类对吧 , 每次变动 , 都需要修改大量代码 。 这种设计的耦合性太高了, 牵一发而动全身。
那我们如何去解决呢 ?
我们可以在需要用到他的地方 , 不去实现它 , 而是留出一个接口 , 利用set , 我们去service实现类代码里修改下 .
public class UserServiceImpl implements UserService {
private UserDao userDao;
// 利用set实现，动态值得注入
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
@Override
public void getUser() {
userDao.getUser();
}
}
现在去我们的测试类里 , 进行测试 ;
@Test
public void test(){
UserServiceImpl service = new UserServiceImpl();
service.setUserDao( new UserDaoMySqlImpl() );
service.getUser();
//那我们现在又想用Oracle去实现呢
service.setUserDao( new UserDaoOracleImpl() );
service.getUser();
}
这样当出现新的Dao的实现类时，我们就不需要去修改service实现类内方法，而是由调用者在测试类中选择，选择他需要的实现类方法。
在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改原代码！如果程序代码量十分大，修改一次的成本代价十分昂贵！
我们使用一个set接口实现，已经发送了革命性的变化!
- 之前，程序是主动创建对象，控制权在程序员手上
- 使用set注入后，程序不再具有主动性，而是变成了被动的接受对象！
- 不用去管怎么创建，怎么实现，只负责提供一个接口
这种思想 , 从本质上解决了问题 , 我们程序员不再去管理对象的创建了 , 更多的去关注业务的实现，耦合性大大降低，这也就是IOC的原型 !
2.2、IOC本质
之前编程
set编程，主动权变为用户
控制反转IOC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IOC的一种方法，也有人认为DI只是IOC的另一种说法。没有IOC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。
IOC是Spring框架的核心内容，使用多种方式完美的实现了IOC，可以使用XML配置，也可以使用注解，新版本的Spring也可以零配置实现IOC。
Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使用时再从IOC容器中取出需要的对象。
采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IOC容器，其实现方法是依赖注入（Dependency Injection,DI）
2.3、HelloSpring
实体类
public class Hello {
private String str;
public String getStr() {
return str;
}
public void setStr(String str) {
this.str = str;
}
@Override
public String toString() {
return "Hello{" +
"str='" + str + '\'' +
'}';
}
}
xml文件
beans.xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="hello" class="com.ssxxz.pojo.Hello">
<property name="str" value="spring"/>
bean>
beans>
正常情况： 类名 变量名 = new 类型（）
Hello hello = new Hello()
Spring:
-
id = 变量名
-
class = new 的对象
-
property 相当于给对象中的属性设置一个值
- name = 需要设置的属性名
- value = 打算设置的属性值
测试
ApplicationContext构造器实例化Spring
public class MyTest {
public static void main(String[] args) {
//获取spring的上下文对象，获取
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//我们的对象现在都在spring中管理，我们要使用，直接去spring容器中取出来
Hello hello = (Hello) context.getBean("hello");
System.out.println(hello.toString());
}
}
使用Spring后发现，已经不需要手动new对象，对象是在xml文件中配置。或者通俗来讲，不需要改底层代码，而xml文件不算底层代码。
这个过程就叫控制反转
控制： 谁来控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象是由Spring来创建的
反转: 程序本身不创建对象，而变成被动的接收对象。
依赖注入： 就是利用set方法来进行注入的
IOC是一种编程思想，由主动的编程变为被动的接收，可以通过newClassPathXmlApplicationContext去浏览一下底层源码
2.4、修改之前的代码
编写beans.xml文件
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="mysqlImpl" class="com.ssxxz.dao.UserDaoMysqlImpl"/>
<bean id="oracleImpl" class="com.ssxxz.dao.UserDaooracleImpl"/>
<bean id="UserServiceImpl" class="com.ssxxz.service.UserServiceImpl">
<property name="userDao" ref="mysqlImpl"/>
bean>
beans>
- ref:引用Spring容器中创建好的对象
- value:具体的值，基本数据类型！
测试
public class MyTest {
public static void main(String[] args) {
//获取ApplicationContext 拿到Spring的容器
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//容器在手，天下我有，需要什么，就直接gei什么
UserServiceImpl userServiceImpl = (UserServiceImpl) context.getBean("UserServiceImpl");
userServiceImpl.getUser();
}
}
想获取其他值，只需要修改beans.xml配置文件中的ref值，不需要修改代码。
到了现在，我们彻底不用再程序中去修改了，要实现不同的操作，只需要在xml配置文件中进行修改，所谓的IOC，一句话搞定：对象由Spring来创建，管理，装配
2.5、IOC创建对象的方式—构造器注入
默认使用无参构造创建对象
使用有参构造创建对象的三种方式
Constructor Argument Resolution 构造器函数
public class User {
private String name;
private int age;
public User(String name, int age) {this.name = name;this.age = age;}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public int getAge() {return age;}
public void setAge(int age) {this.age = age;}
}
1、下标赋值 Constructor argument index
<bean id="user" class="com.ssxxz.entity.User">
<constructor-arg index="0" value="张三"/>
<constructor-arg index="1" value="18"/>
bean>
- index 下标的第几个方法
2、变量类型赋值 Constructor argument type matching
<bean id="user1" class="com.ssxxz.entity.User">
<constructor-arg type="int" value="18"/>
<constructor-arg type="java.lang.String" value="张三"/>
bean>
- 基本类型可以直接用，引用类型需要全限定名
- 但是怕有相同的类型，比如两个Int，所以不建议使用
3、变量名称赋值 Constructor argument name
<bean id="user2" class="com.ssxxz.entity.User">
<constructor-arg name="name" value="张三"/>
<constructor-arg name="age" value="18"/>
bean>
在获取spring的上下文对象（ new ClassPathXmlApplicationContext(“beans.xml”); ）时，spring容器中的所有的对象就已经被创建了。
3、Spring的基础配置
3.1、别名 alias
<bean id="user" class="com.ssxxz.entity.User">
<constructor-arg index="0" value="张三"/>
<constructor-arg index="1" value="18"/>
bean>
<alias name="user" alias="userAlias"/>
- 两个都能获取，使用原来的
User也行，使用userAlias也行
3.2、Bean的配置
<bean id="user1" class="com.ssxxz.entity.User" name="test test1, test2; test3">
<constructor-arg type="int" value="18"/>
<constructor-arg type="java.lang.String" value="张三"/>
bean>
- id: bean的唯一标识符，也就是相当于我们学的对象名
- class： bean对象的全限定名：包名 + 类型
- name： 也是别名 而且name可以同时设置多个别名，可以用逗号 空格 分号隔开
3.3、import
import，一般用于团队开发使用，他可以将多个配置文件，导入合并为1个
假设，现在项目中又多个人开发，这三个人负责不同的类开发，不同的类需要注册在不同的bean中，我们可以用import将所有人的beans.xml合并为一个总的！
beans.xml
beans2.xml
beans3.xml
合并到applicationContext.xml中
<import resource="beans.xml"/>
<import resource="beans2.xml"/>
<import resource="beans3.xml"/>
使用的时候，直接使用总的配置就可以了
4、DI 依赖注入
4.1、构造器注入
前面已经说过
4.2、set方式注入 【重点】
依赖注入
-
依赖：bean对象的创建依赖于容器
-
注入：bean对象中的所有属性，由容器来注入
环境搭建
1、复杂类型
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "Address{" +
"address='" + address + '\'' +
'}';
}
}
2、真实测试对象
import java.util.*;
public class Student {
private String name;
private Address address;
private String [] books;
private List<String> hobbies;
private Map<String, String> card;
//set无序，不可重复
private Set<String> games;
//空指针
private String wife;
//配置类
private Properties info;
//Getter、Setter和toString
}
注意：private Address address;本身就是复制方法类，所以需要toString它的方法的toString，Address.toString(address)
3、applicationContext.xml
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="address" class="com.ssxxz.entity.Address">
<property name="address" value="左左右右"/>
bean>
<bean id="student" class="com.ssxxz.entity.Student">
<property name="name" value="上上下下"/>
<property name="address" ref="address"/>
<property name="books">
<array>
<value>红楼梦value>
<value>三国演义value>
<value>水浒传value>
<value>西游记value>
array>
property>
<property name="hobbies">
<list>
<value>抽烟value>
<value>喝酒value>
<value>烫头value>
list>
property>
<property name="card">
<map>
<entry key="身份证" value="1234567891234"/>
<entry key="银行卡" value="98765432112"/>
map>
property>
<property name="games">
<set>
<value>LOLvalue>
<value>COCvalue>
<value>BOBvalue>
set>
property>
<property name="wife">
<null/>
property>
<property name="info">
<props>
<prop key="url">驱动prop>
<prop key="username">rootprop>
<prop key="password">123456prop>
props>
property>
bean>
beans>
4、测试类
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
Student student = (Student) context.getBean("student");
System.out.println(student);
/*
* Student{
* name='ssxxz',
* address=Address{address='Dalian'},
* books=[红楼梦, 三国演义, 水浒传, 西游记],
* hobbies=[抽烟, 喝酒, 烫头],
* card={身份证=220......., 银行卡=626.......},
* games=[LOL, COC, BOB],
* wife='null',
* info={password=123456, name=root, driver=驱动}}
* */
}
}
查看官网文档学习
https://docs.spring.io/spring-framework/docs/current/reference/html/core.html#beans-basics
4.3、p 、c 标签注入
我们可以使用p 、c 标签注入，但需要导入第三方xml约束
p 标签注入，须在beans中引入xmlns:p="http://www.springframework.org/schema/p"
<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"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="p_test" class="com.ssxxz.entity.Student" p:name="ssxxz"/>
c 标签注入，需在实体中增加有参构造方法，并引入 xmlns:c="http://www.springframework.org/schema/c"
<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/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="c_test" class="com.ssxxz.entity.Address" c:address="DL"/>
4.4、Bean的作用域
Bean Scopes
1、单例模式 singleton（Spring默认机制，全局唯一）
2、原型模式 prototype ：每一个对象都有一个自己的，每次从容器中get对象时，都重新创建
3、其余的request、session、application、websocket这些只能在web开发中使用
5、Bean的自动装配
- 自动装配是spring满足bean依赖的一种方式
- Spring会在上下文中自动寻找，并自动给bean装配属性
在Spring中由三种装配方式
- 在xml中显式配置
- 在java中显式配置
- 隐式的自动装配bean
5.1、autowire—ByName与ByType自动装配
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="cat" class="com.ssxxz.entity.Cat"/>
<bean id="dog" class="com.ssxxz.entity.Dog"/>
<bean id="people" class="com.ssxxz.entity.People" autowire="byName">
<property name="name" value="上上下下"/>
bean>
<bean id="people1" class="com.ssxxz.entity.People" autowire="byType">
<property name="name" value="上上下下"/>
bean>
beans>
小结：
byName的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致
byType的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致
5.2、使用注解实现自动装配
jdk1.5支持的注解 Spring2.5支持的注解
The introduction of annotation-based configuration raised the question of whether this approach is “better” than XML
使用注解须知：
1、导入约束：context约束
（xmlns:context=“http://www.springframework.org/schema/context” http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd）
2、配置注解的支持
<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/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<context:annotation-config/>
beans>
实体类上加 @Autowired 就可以自动装配导入
5.3、@Autowired与@Resource
1、@Autowired
- 直接在属性上使用即可！也可以在set方式上使用，就不需要写 setDog 方法了
- 使用Autowired我们可以不用编写set方法了，前提是你这个自动装配的属性在IOC（Spring）容器中存在，且符合名字byName
@Nullable
@Nullable 字段标记了这个注解，说明这个字段可以为null；
//标注了，即使name为空也不会报错
public People(@Nullable String name){
this.name = name;
}
@Autowired 也可以null不错
@Autowired 唯一属性默认为 true
public @interface Autowired{
boolean required() default true;
}
如果 required = false 就可以为null
public class People {
//如果定义了Autowired的required属性为false，说明这个对象可以为null，否则不允许为空
@Autowired(required = false)
private Cat cat;
@Autowired
private Dog dog;
private String name;
}
@Qualifier
如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以使用@Qualifier（value = “xxx”）去配置@Autowired的使用，指定一个唯一的bean对象注入！
public class People {
@Autowired()
private Cat cat;
@Autowired
@Qualifier(value = "xxx")
private Dog dog;
private String name;
}
2、@Resource
@Resource注解，类似byName和byType的集合，先判断 id 再判断 class 有一个能注入即成功，也可以指定name值使用
public class People {
@Resource(name = "xxxx")
private Cat cat;
小结：@Resource和@Autowired的区别
- 都是用来自动装配的，都可以放在属性字段上
- @Autowired 通过byType的方式实现，而且必须要求这个对象存在！如果不唯一则需要通过
@Qualifier（value = “xxx”）实现 - @Resource 默认通过byName的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！
- 执行顺序不同：@Autowired通过byType的方式实现。@Resource默认通过byName的方式实现。
6、使用注解开发
在Spring4之后，要使用注解开发，必须保证aop的包导入了
使用注解需要导入context约束，增加注解的支持！
<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/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<context:component-scan base-package="com.ssxxz.pojo"/>
<context:annotation-config/>
beans>
1、bean注入使用@Componet注解
放在类上，说明这个类被Spring管理了，就是bean
//@Component 等价于test类
public static void main(String[] args){
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//bean的id就是方法名的小写
User user = (User) context.getBean("user");
System.out.println(user.name());
}
bean的id就是方法名的小写
2、属性注入使用@Value注解
//@Component 等价于3、衍生注解
@Componet有几个衍生注解，我们在web开发中，会按照mvc三层架构分层！
- dao层 【@Repository】
- service层 【@Service】
- controller层 【@Controller】
这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean
4、自动装配
- @Autowired 自动装配通过类型、名字
- 如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value=“xxx”)
- @Nullable 字段标记了这个注解，说明这个字段可以为null
- @Resource 自动装配通过名字，类型
5、作用域
@Scope(“singleton”) 单例
@Scope(“prototype”) 原型
@Component @Component 组件bean
@Scope(“prototype”) //作用域
public class User {
String name;
@Value("ssxxz") //属性注入
public void setName(String name) {
this.name = name;
}
}
6、小结
XML 与 注解
-
xml更加万能，适用于任何场合！维护简单方便
-
注解不是自己类使用不了， 维护相对复杂
XML 与 注解最佳实践
- xml用来管理bean
- 注解只负责完成属性的注入
- 我们在使用过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持
<context:annotation-config/>
<context:component-scan base-package="com.ssxxz"/>
7、使用Java的方式配置Spring
我们现在要完全不使用Spring的xml配置，全权交给Java来做
以前 JavaConfig 是Spring的一个子项目，在 Spring4 之后它成为了一个核心功能
@Component 类似于 beans
实体类
@Component 这里这个注解的意思，就是说明这个类被Spring接管了，注册到了容器中
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
//这里这个注解的意思，就是说明这个类被Spring接管了，注册到了容器中
@Component
public class User {
private String name;
public String getName() {
return name;
}
@Value("ssxxz")//属性注入值
public void setName(String name) {
this.name = name;
}
}
配置类
@Configuration 代表这个配置类，与applicationContext.xml一样
@ComponentScan(“com.ssxxz.pojo”) 扫描包
@Bean 注册一个Bean，就相当于我们之前写的一个bean标签
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
//@Configuration,这个也会被Spring容器托管，注册到容器中，因为打开注解，它本身就被定义为组件了@Component
//@Configuration代表了这是一个配置类，与applicationContext.xml一样
@Configuration
@ComponentScan("com.ssxxz.pojo")
//引入其他类
@Import(ssConfig2.class)
public class YangConfig {
//注册一个Bean，就相当于我们之前写的一个bean标签
//方法名字 == bean标签的id
//方法的返回值 == bean标签中的class属性
@Bean
public User getUser () {
return new User();//就是返回要注入到bean的对象
}
}
测试类
public class MyTest {
public static void main(String[] args) {
//如果完全使用了配置类方式去做，我们就只能通过 ApplicationContext 上下文来获取容器，通过配置类的class对象加载
ApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(YangConfig.class);
//"getUser"是小写的配置方法名
User getUser = (User)annotationConfigApplicationContext.getBean("getUser");
System.out.println(getUser.getName());
}
}
ApplicationContext注解的配置类
这种纯Java的配置方式，在SpringBoot中随处可见
8、代理模式
SpringAOP的底层就是代理模式 【SpringAOP 和 SpringMVC】
代理模式的分类：
- 静态代理
- 动态代理
租房的代理模式
8.1、静态代理
角色分析：
- 抽象角色：一般会使用接口或者抽象类来解决
- 真实角色：被代理的角色
- 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
- 客户：访问代理对象的人
代码步骤：
-
接口—事情租房
//租房 public interface Rent{ public void rent(); } -
真实角色—房东
public calss Host interface Rent{ public void rent(){ System.out.println("房东要出租房子！"); } } -
代理角色—中介
public calss Proxy interface Rent{ private Host host; public Proxy(){ } public Proxy(Host host){ this.host = host; } //房东只需要出租房屋 //但是中介代理租房的其他事务 public void rent(){ seeHouse(); host.rent(); hetong(); fare(); } //看房 public void seeHouse(){ System.out.println("中介带你看房！"); } //签合同 public void seeHouse(){ System.out.println("签租赁合同！"); } //收中介费 public void seeHouse(){ System.out.println("收中介费！"); } } -
客户端访问代理角色
public calss Client{ //房东要租房子 Host host = new Host(); //代理，中介帮房东租房，还是还有其他一些附属操作 Proxy proxy = new Proxy(host); //你不用面对房东，直接找中介租房即可 proxy.rent(); }
代理模式的好处：
- 可以使真实角色的操作更加存粹！不用去关注一些公共的业务
- 公共交给了代理角色，实现了业务的分工
- 公共业务发生扩展的时候，方便集中管理
缺点：
- 一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率变低
再理解
代理模式的横向开发
再一个原有的代码上，增加一个日志功能
为了保证原来的代码安全，不可以直接在上面改，需要通过添加一个代理类，添加日志功能
接口类
public interface UserService{
public void add();
public void delete();
public void upadte();
public void query();
}
实现类
public class UserServiceImpl interface UserService{
public void add(){
System.out.println("添加了一个用户！");
};
public void delete(){
System.out.println("删除了一个用户！");
};
public void upadte(){
System.out.println("修改了一个用户！");
};
public void query(){
System.out.println("查询了一个用户！");
};
}
代理类
创建代理类添加日志功能
public class UserServiceProxy interface UserService{
//创建set方法，准备获取实体类
private UserServiceImpl userService;
public void setUserService(UserService userService){
this.userService = userService;
}
public void add(){
log("add");
userService.add();
};
public void delete(){
log("delete");
userService.delete();
};
public void upadte(){
log("upadte");
userService.upadte();
};
public void query(){
log("query");
userService.query();
};
//日志方法
public void log(String msg){
System.out.println("[Debug] 使用了"+msg+"方法");
}
}
测试类
public class Client(){
public static void main(String[] args) {
//创建实体类
UserServiceImpl userService = new UserServiceImpl();
//创建代理类
UserServiceProxy proxy = new UserServiceProxy();
//将实体类传入代理来中关联
proxy.setUserService(userService);
proxy.query();
}
}
改动原有的业务代码，在公司中是大忌！
8.2、动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的，不是我们直接写好的
- 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口：JDK动态代理
- 基于类： cglib
- java字节码实现： javasist
需要了解两个类：
- Proxy：代理，提供动态代理类和实例的静态方法
- InvocationHandler：调用处理程序的实现类接口
1、普通方法测试
调用处理工具类
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//我们会用这个类，自动生成代理类的类
public class ProxyInvocationHandler implements InvocationHandler {
//被代理的接口
private Rent rent;
public void setRent (Rent rent) {
this.rent = rent;
}
//生成得到代理类
public Object getProxy () {
return Proxy.newProxyInstance(this.getClass().getClassLoader(),
rent.getClass().getInterfaces(), this);
}
//处理代理实例，并返回结果
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//动态代理的本质，就是使用反射机制实现！
seeHouse();
Object result = method.invoke(rent, args);
fare();
return result;
}
//添加自己代理方法
public void seeHouse(){
System.out.println("中介带看房子");
}
public void fare(){
System.out.println("收中介费");
}
}
测试，创建代理类和测试一起
public class Client {
public static void main(String[] args) {
//真实角色
Host host = new Host();
//代理角色，不存在，创建代理工具
ProxyInvocationHandler pih = new ProxyInvocationHandler();
//通过调用程序处理角色（代理工具）来处理我们要调用的接口对象（真实角色）
pih.setRent(host);
//proxy就是动态生成的代理类，我们并没有写
Rent proxy = (Rent)pih.getProxy();
proxy.rent();
}
}
2、抽象方法测试
被代理的接口类型并没有写死，变成抽象的Object类
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//自动生成代理类的类
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);
}
//处理代理实例，并返回结果
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 class UserServiceImpl implements UserServiceInterface{
public void add() {
System.out.println("增加一个用户");
}
public void delete() {
System.out.println("删除一个用户");
}
public void update() {
System.out.println("更新一个用户");
}
public void select() {
System.out.println("检索一个用户");
}
}
测试类
public class Client {
public static void main(String[] args) {
//真实角色
UserServiceImpl userService = new UserServiceImpl();
//代理角色，不存在
ProxyInvocationHandler pih = new ProxyInvocationHandler();
//设置要代理的对象
pih.setTarget(userService);
//动态生成代理类
UserService proxy = (UserService)pih.getProxy();
proxy.add();
}
}
3、动态代理的好处
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的业务
- 公共也就交给代理角色！实现了业务的分工
- 公共业务发送扩展的时候，方便集中管理！
- 一个动态代理类代理的是一个接口，一般就是对应的一类业务
- 一个动态代理类可以代理多个类，只要是实现了同一个接口即可
9、AOP
9.1、什么是AOP
AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术，AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生泛型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
9.2、Aop在Spring中的作用
提供生命事务：允许用户自定义切面
- 横切关注点：跨越应用程序多个模块的方法或功能。即与我们的业务逻辑无关的，但是我们需要关注的部分,就是横切关注点。如日志，安全，缓存，事务等等 …
- 切面（ASPECT）：横切关注点 被模块化的特殊对象。即，它是一个类
- 通知（Advice）：切面必须要完成的工作，即 他是类中的一个方法
- 目标（target）：被通知的对象
- 代理（Proxy）：向目标对象应用通知之后创建的对象
- 切入点（PointCut）：切面通知 执行的"地点"的定义
- 连接点（jointPoint）：与切入点匹配的执行点
SpringAop中，通过Advice定义横切逻辑，Spring中支持的5种类型的Advice
即 Aop 在不改变原有代码的情况下，去增加新的功能
9.3、使用Spring实现Aop
【重点】使用AOP织入，需要依赖包
<dependency>
<groupId>org.aspectjgroupId>
<artifactId>aspectjweaverartifactId>
<version>1.9.4version>
dependency>
方式一：使用Spring的API接口
【主要是SpringAPI接口实现】
com.ssxxz.service
UserServer接口
public interface UserService {
public void add();
public void delete();
public void update();
public void select();
}
com.ssxxz.service
UserServer实现类
public class UserServiceImpl implements UserService{
public void add() {
System.out.println("增加了一个用户");
}
public void delete() {
System.out.println("删除了一个用户");
}
public void update() {
System.out.println("更新了一个用户");
}
public void select() {
System.out.println("检索了一个用户");
}
}
com.ssxxz.log
Log类 执行前
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
//MethodBeforeAdvice 执行前
public class Log implements MethodBeforeAdvice {
//method:要执行的目标对象的方法（method being invoked）
//object:参数（args: arguments to the method）
//o:目标对象 （target：target of the method invocation）
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println(target.getClass().getName() + "的" + method.getName() + "被执行了");
}
}
AfterLog类 执行后
import org.springframework.aop.AfterReturningAdvice;
import java.lang.reflect.Method;
//AfterReturningAdvice 执行后
public class Log implements AfterReturningAdvice {
//returnValue:返回值
public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
System.out.println("执行了" + method.getName() + "方法，返回值为" + returnValue);
}
}
配置文件
resources
applicationContext.xml
<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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="userService" class="com.ssxxz.service.UserServiceImpl"/>
<bean id="log" class="com.ssxxz.log.Log"/>
<bean id="afterLog" class="com.ssxxz.log.AfterLog"/>
<aop:config>
<aop:pointcut id="pointcut" expression="execution(* com.ssxxz.service.UserServiceImpl.*(..))"/>
<aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
aop:config>
beans>
测试类
import com.ssxxz.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
//动态代理代理的是接口，实体类的话就会报错
UserService userService = context.getBean("userService", UserService.class);
userService.add();
}
}
方式二：自定义来实现AOP
【主要是切面定义】
resources
applicationContext.xml
<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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="userService" class="com.ssxxz.service.UserServiceImpl"/>
<bean id="log" class="com.ssxxz.log.Log"/>
<bean id="afterLog" class="com.ssxxz.log.AfterLog"/>
<bean id="diy" class="com.ssxxz.diy.DiyPointCut"/>
<aop:config>
<aop:aspect ref="diy">
<aop:pointcut id="point" expression="execution(* com.ssxxz.service.UserServiceImpl.*(..))"/>
<aop:before method="before" pointcut-ref="point"/>
<aop:after method="after" pointcut-ref="point"/>
aop:aspect>
aop:config>
beans>
自定义类
com.ssxxz.diy
DiyPointCut
public class DiyPointCut {
public void before(){
System.out.println("===方法执行前===");
}
public void after(){
System.out.println("===方法执行后===");
}
}
方式三：使用注解实现AOP
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
//注意包不要倒错，需要annotation的包
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
@Aspect //标注这个类是一个切面
public class AnnotationPointcut {
//切入点
@Before("execution(* com.ssxxz.service.UserServiceImpl.*(..))")
public void before () {
System.out.println("====方法执行前====");
}
@After("execution(* com.ssxxz.service.UserServiceImpl.*(..))")
public void after () {
System.out.println("====方法执行后====");
}
//在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
@Around("execution(* com.ssxxz.service.UserServiceImpl.*(..))")
public void around (ProceedingJoinPoint jp) throws Throwable {
System.out.println("环绕前");
Signature signature = jp.getSignature();//获得签名，执行了那个方法
System.out.println("signature" + signature);
//执行方法
Object proceed = jp.proceed();//执行方法
System.out.println("环绕后");
}
}
执行顺序：“环绕前” → “方法执行前” →（执行方法）→ “环绕后” → “方式执行后”
XML文件
<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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="userService" class="com.ssxxz.service.UserServiceImpl"/>
<aop:aspectj-autoproxy proxy-target-class="false"/>
<bean id="annotationPointCut" class="com.ssxxz.diy.AnnotationPointcut"/>
<beans/>
10、整合Mybatis
步骤：
- 导入相关jar包
- 编写配置文件
- 测试
1、导入相关jar包
- junit
- mybatis
- mysql数据库
- spring相关的
- aop织入
- mybatis-spring
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<artifactId>spring-studyartifactId>
<groupId>com.ssxxzgroupId>
<version>1.0-SNAPSHOTversion>
parent>
<modelVersion>4.0.0modelVersion>
<artifactId>spring-10-mybatisartifactId>
<dependencies>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.13version>
<scope>testscope>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>5.1.47version>
dependency>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.5.2version>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webmvcartifactId>
<version>5.2.0.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-jdbcartifactId>
<version>5.1.9.RELEASEversion>
dependency>
<dependency>
<groupId>org.aspectjgroupId>
<artifactId>aspectjweaverartifactId>
<version>1.9.4version>
dependency>
<dependency>
<groupId>org.aspectjgroupId>
<artifactId>aspectjrtartifactId>
<version>1.8.13version>
dependency>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatis-springartifactId>
<version>2.0.2version>
dependency>
<dependency>
<groupId>org.projectlombokgroupId>
<artifactId>lombokartifactId>
<version>1.16.10version>
dependency>
dependencies>
<build>
<resources>
<resource>
<directory>src/main/javadirectory>
<includes>
<include>**/*.xmlinclude>
includes>
<filtering>truefiltering>
resource>
resources>
build>
project>
10.1、回忆mybatis
1、编写实体类
User
com.ssxxz.pojo
@Data
public class User{
private int id;
private String name;
private String pwd;
}
2、编写核心配置文件
mybatis-config.xml
resources
DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<typeAliases>
<package name="com.ssxxz.pojo"/>
typeAliases>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
dataSource>
environment>
environments>
<mappers>
<mapper class="com.ssxxz.mapper.UserMapper"/>
mappers>
configuration>
3、编写接口
UserMapper.java
com.ssxxz.mapper
public interface UserMapper {
public List<User> selectUser();
}
4、编写Mapper.xml
UserMapper.xml
com.ssxxz.mapper
DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ssxxz.mapper.UserMapper">
<select id="selectUser" resultType="user">
select * from mybatis.user;
select>
mapper>
5、测试
public class MyTest {
@Test
public void test () throws IOException {
String resources ="mybatis-config.xml";
InputStream in = Resources.getResourcesAsStream(resources);
SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);
SqlSession sqlSession = sessionFactory.openSession(true);
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> userList = mapper.selectUser();
for (User user : userList) {
System.out.println(user);
}
}
}
10.2、MyBatis-Spring
官方文档地址：https://mybatis.org/spring/zh/index.html
MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。它将允许 MyBatis 参与到 Spring 的事务管理之中，创建映射器 mapper 和 SqlSession 并注入到 bean 中，以及将 Mybatis 的异常转换为 Spring 的 DataAccessException。 最终，可以做到应用代码不依赖于 MyBatis，Spring 或 MyBatis-Spring。
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-jdbcartifactId>
<version>5.1.9.RELEASEversion>
dependency>
步骤：
- 编写数据源配置
- SqlSessionFactory
- SqlSessionTemplate
- 需要给接口加实现类
- 将自己写得实现类，注入到Spring中
- 测试使用即可
编写配置文件代替mybatis
spring-dao.xml
resources
<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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<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=true&useUnicode&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="configLocation" value="classpath:mybatis-config.xml" />
<property name="mapperLocations" value="classpath:com/ssxxz/mapper/*.xml" />
bean>
<bean id="sqlSession" class="org.mybatis.spring.sqlSessionTemplate">
<constructor-arg index="0" ref="sqlSessionFactory"/>
bean>
<bean id="userMapper" class="com.ssxxz.mapper.UserMapperImpl">
<property name="sqlSession" ref="sqlSession"/>
bean>
beans>
这样大部分都可以在这里设置，Mabatis只留下一些设置
以后会经常使用xxxxTemplate：模板，比如redisTemplate，thymeTemplate
也可以在将配置对象导出来，这样数据库内容就不需要修改了
applicationContext.xml
<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
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd">
<inport resource="spring-dao.xml"/>
<bean id="userMapper" class="com.ssxxz.mapper.UserMapperImpl">
<property name="sqlSession" ref="sqlSession"/>
bean>
beans>
需要再添加一个对象实现类
SqlSessionTeamplate
public class UserMapperImpl implements UserMapper{
//原来我们的所有操作，都使用sqlSession来执行
//现在都使用SqlSessionTemplate
private SqlSessionTeamplate sqlSession;
public void setSqlSession(SqlSessionTeamplate sqlSession){
this.sqlSession = sqlSession;
}
public List<User> selectUser(){
UserMapper mapper = sqlSession.getMapper(UserMapper,class);
return mapper.selectUser();
}
}
以前是将方法写到测试类，现在方法写到对象中，只需要在测试类中调用即可
测试类
public class MyTest {
@Test
public void test () throws IOException {
ApplicationContext context = new ClassPathXmlApplicationContext("sqring-dao.xml");
UserMapper userMapper = context.getMapper("userMapper",UserMapper.class);
for (User user : userMapper.selectUser) {
System.out.println(user);
}
}
}
10.3、SqlSessionDaoSupport 再进行简化
SqlSessionDaoSupport 是一个抽象的支持类，用来为你提供 SqlSession。调用 getSqlSession() 方法你会得到一个 SqlSessionTemplate，之后可以用于执行 SQL 方法，就像下面这样:
import com.ssxxz.entity.User;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.support.SqlSessionDaoSupport;
import java.util.List;
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
public List<User> selectUser() {
SqlSession sqlSession = getSqlSession();
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> users = mapper.selectUser();
//return getSqlSession().getMapper(UserMapper.class).selectUser();
return users;
}
}
并且不需要注入属性，直接注入父类sqlSessionFactory即可
<bean id="userMapper" class="com.ssxxz.mapper.UserMapperImpl">
<property name="sqlSessionFactory" ref="sqlSessionFactory"/>
bean>
Mybatis插件：Mybatis-plus ， 通用Mybatis
11、声明式事务
1、回顾事务
- 把一组业务当做一个业务来做，要么都成功，要么都失败！
- 事务在项目开发中，十分的重要，涉及到数据的一致性问题，不能马虎
- 确保完整性和一致性
事务ACID原则：
- 原子性
- 一致性
- 隔离性
- 多个业务可能操作同一资源，防止数据损坏
- 持久性
- 事务一旦提交，无论系统发送什么问题， 结果都不会再被影响，被持久化的写到存储器中
2、事务流程回顾
- pom 依赖
- pojo 实体类
- UserMapper接口
- mybatis
- 配置文件 mybatis-config.xml
- 整合mybatis—spring-dao.xml
- 配置数据源
- SqlSessionFactory
- SqlSession
- UserMapper.xml 输入sql语句
- UserMapper 实现类—继承SqlSessionDaoSupport
- 配置Srping —applicationContext.xml
- 测试
最后测试发现，即使有sql语句错误，程序执行失败，但是其他正确的sql语句还会有执行成功的，这不符合事务ACID一致性原则
3、Srting中的事务管理
想要有一条程序执行失败时，保证其他程序也同时失败
- 声明式事务：AOP，代码是横切进去的，不影响原有代码
- 交由容器管理事务
- 编程式事务：需要在代码中，进行事务的管理
- 使用try-catch
声明式事务
- 事务处理器配置声明
- 然后交给交由容器管理事务，导入tx事务
- 配置事务切入
spring-dao.xml
<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"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
https://www.springframework.org/schema/aop/spring-aop.xsd
http://www.springframework.org/schema/tx
http://www.springframework.org/schema/tx/spring-tx.xsd">
<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=true&useUnicode&characterEncoding=UTF-8"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="configLocation" value="classpath:mybatis-config.xml" />
<property name="mapperLocations" value="classpath:com/ssxxz/mapper/*.xml" />
bean>
<bean id="sqlSession" class="org.mybatis.spring.sqlSessionTemplate">
<constructor-arg index="0" ref="sqlSessionFactory"/>
bean>
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
bean>
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="add" propagation="REQUIRED"/>
<tx:method name="delete" propagation="REQUIRED"/>
<tx:method name="update" propagation="REQUIRED"/>
<tx:method name="select" read-only="true"/>
<tx:method name="*" propagation="REQUIRED"/>
tx:attributes>
tx:advice>
<aop:config>
<aop:pointcut id="txPointCut" expression="execution(* com.ssxxz.mapper.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
aop:config>
beans>
配置事务的传播特性 propagation
- PROPAGATION_REQUIRED:如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择，也是默认选择。
- PROPAGATION_SUPPORTS:支持当前事务，如果没有当前事务，就以非事务方法执行。
- PROPAGATION_MANDATORY:使用当前事务，如果没有当前事务，就抛出异常。
- PROPAGATION_REQUIRES_NEW:新建事务，如果当前存在事务，把当前事务挂起。
- PROPAGATION_NOT_SUPPORTED:以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
- PROPAGATION_NEVER:以非事务方式执行操作，如果当前事务存在则抛出异常。
- PROPAGATION_NESTED: 如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED 类似的操作
思考，为什么需要事务？
- 如果不配置事务，可能存在数据提交不一致的情况下
- 如果我们不在SPRING中去配置声明式事务，我们就需要在代码中手动配置事务
- 事务在项目的开发中十分重要，设计到数据的一致性和完整性问题，不容马虎