Spring
1、Spring
1.1、简介
-
Spring 是一个轻量级控制反转IOC和面向切面AOP的容器框架
-
2002,首次推出Spring框架的雏形，interface21框架
-
Spring框架即以interface21框架为基础经过重新设计，并不断丰富其内涵，于2004.3.24发布了1.0正式版
-
Rod Johnson，SpringFramework创始人，不是计算机专业，一个音乐家
-
spring理念，是现有技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>6.1.6</version> </dependency>
1.2 优点
-
开源免费的框架
-
轻量级的、非入侵的框架
-
控制反转（IOC），面向切面编程（AOP）
-
支持事务的处理，对框架整合的支持
总结：Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架
2、IOC理论推导
1.UserDao接口
package com.twd.dao;
public interface UserDao {
void getUser();
}
2.UserDaoImpl实现类
package com.twd.dao;
public class UserDaoImpl implements UserDao{
@Override
public void getUser() {
System.out.println("默认获取用户数据");
}
}
3.UserService业务接口
4.User ServiceImpl业务实现类
public class UserServiceImpl implements UserService{
private UserDao userDao;
//利用set进行动态实现值的注入
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
public void getUser(){
userDao.getUser();
}
}
在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改源代码，如果程序量十分大，修改一次的成本代价十分昂贵！
我们使用一个set接口实现，已经发生了革命性的变化
private UserDao userDao;
//利用set进行动态实现值的注入
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
-
之前程序是主动创建，控制权在程序员手上
-
使用了set注入后，程序不在具有主动性，从而变成了被动的接收对象
这种思想，从本质上解决了问题，我们程序员不在去管理对象的创建，系统的耦合性大大降低，可以更加专注在业务的实现上，这就是和IOC的原理
IOC本质
控制反转IOC(Inversion of Control)，是一种设计思想，DI(依赖注入)是实现IOC的一种方法
控制反转是一种通过描述（XML或注解）并通过第三方生产或获取特定对象的方式，在Spring中实现控制反转的是IOC容器，其实现方式是依赖注入（Dependency Injection DI）
3、HelloSpring
package com.twd.pojo;
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 version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <!--使用spring来创建对象，在spring这些都称之为Bean--> <bean id="hello" class="com.twd.pojo.Hello"> <property name="str" value="Spring"/> </bean> </beans>
import com.twd.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
public static void main(String[] args) {
//获取Spring的上下文对象
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
//我们的对象现在spring中的管理了，我们要使用，直接去里面取出来即可
Hello hello = (Hello) context.getBean("hello");
System.out.println(hello.toString());
}
}
修改直接到配置文件修改
这个过程就叫控制反转
控制：控制对象的创建，
反转：程序本身不创建对象，而变成被动的接受对象
依赖注入：就是利用set方法来进行注入
IOC是一种编程思想，由主动的编程变为被动的接受
可以通过new ClassPathXmlApplicationContext去浏览一下底层代码
要实现不同的操作，只需在xml配置文件中进行修改，所谓的IOC，一句话搞定：对象由spring来创建，管理，装饰
4、IOC创建对象的方式
1.使用无参构造创建对象
2.如果要用有参构造函数创建
<bean id="user" class="com.twd.pojo.User"> <constructor-arg name="name" value="123"/> </bean> <-- 直接通过参数名来设置-->
总结，在配置文件加载的时候，容器中的管理对象就已经初始化了。
5、Spring配置
5.1 别名
<alias name="user" alias="fysyyds"/>
就是取别名
5.2 Bean配置
<bean id="user" class="com.twd.pojo.User" name="111111">
name:也是取别名
5.3 import
一般用于团队开发，他们可以将多个配置文件，导入合并为一个
假设现在项目中有多个人开发，这三个人复制不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的
使用的时候，直接使用总的配置就可以了
6、依赖注入
6.1 构造器注入
6.2 set注入【重点】
-
依赖注入：set注入
-
依赖：bean对象的创建依赖于容器
-
注入：bean对象中的所有属性，由容器来注入
-
【环境搭建】
1.复杂类型
package com.twd.pojo;
public class Address {
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
2.真实测试对象
public class Student {
private String name;
private Address address;
private String[] books;
private List<String> hobby;
private Map<String,String> card;
private Set<String> games;
private String wife;
private Properties info;
}
3.beans.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="student" class="com.twd.pojo.Student"> <property name="name" value="twd"/> </bean> </beans>
4.测试类
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
Student student = (Student) context.getBean("student");
System.out.println(student.getName());
}
}
注册信息
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id="address" class="com.twd.pojo.Address"> <property name="address" value="湖南啧啧啧"/> </bean> <bean id="student" class="com.twd.pojo.Student"> <property name="name" value="twd"/> <property name="address" ref="address"/> <property name="books"> <array> <value>西游记</value> <value>三国演义</value> </array> </property> <property name="hobby"> <list> <value>唱跳rap篮球</value> </list> </property> <property name="card"> <map> <entry key="身份证" value="123123132"/> <entry key="银行卡" value="111111111111"/> </map> </property> <property name="games"> <set> <value>lol</value> <value>coc</value> </set> </property> <property name="wife"> <null/> </property> <property name="info"> <props> <prop key="driver">1232312</prop> <prop key="url">123</prop> <prop key="username">123</prop> <prop key="password">123</prop> </props> </property> </bean> </beans>
6.3 拓展方式注入
可以使用p命名空间和c命名空间
6.4 bean的作用域
六种
1.单例模式（Spring默认）
<bean id="address" class="com.twd.pojo.Address" scope="singleton">
2.原型模式：每次从容器中get的时候，都会产生一个新对象
<bean id="address" class="com.twd.pojo.Address" scope="prototype">
3.其余的request，session，application，这些只能在web开发中使用到
7、Bean的自动装配
-
自动装配是spring满足bean依赖的一种方式
-
spring会在上下文中自动寻找，并自动给bean装饰属性
在spring中有三种装配的方式
1.在xml中显示配置
2.在java中显示配置
3.隐式的自动装配bean
7.1 测试
环境搭建：一个人有两个宠物
7.2 ByName自动装配
<!-- byName:会自动装配容器上下文中查找，和自己对象set方法后面的值对应的beanid--> <bean id="people" class="com.twd.pojo.People" autowire="byName"> <property name="name" value="twd"/> </bean>
7.3 ByType自动装配
<!-- byType:会自动装配容器上下文中查找，找类型相同的--> <bean id="people" class="com.twd.pojo.People" autowire="byType"> <property name="name" value="twd"/> </bean>
小结：
-
byName:需要保证所有的bean的id唯一性，并且这个bean需要和自动注入的属性的set方法的值一样
-
byType:需要保证所有的bean的class唯一性，并且这个bean需要和自动注入的属性类型一样
7.4 使用注解实现自动装配
jdk1.5支持注解，spring2.5支持注解
1.导入约束
2.配置注解的支持:context:annotation-config/
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/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 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <context:annotation-config/> <bean id="dog" class="com.twd.pojo.Dog"/> <bean id="cat" class="com.twd.pojo.Cat"/> <bean id="people" class="com.twd.pojo.People"/> </beans>
然后就可以使用@Autowired了
直接在属性上使用即可，也可以在set方法上面使用
使用Autewired我们可以不用编写set方法了，前提是你这个自动装配的属性在ioc（spring）容器中存在，且符合名字ByName
科普：
@Nullable 字段标记了这个注解，说明这个字段可以为null
public @interface Autowired {
boolean required() default true;
}
定义为false就可以为null
如果@Autowired自动装配环境比较复杂，自动装配无法通过一个注解@Autowired完成的时候，我们可以使用@Qualifier（value=“xxx“）去配置@Autowired的使用，指定一个唯一的bean对象注入
public class People {
@Autowired
@Qualifier(value = "dog222")
private Dog dog;
@Resource
public class People {
@Resource(name = "cat1")
private Dog dog;
小结
@Resource和@Autowired的区别：
-
都是用来自动装配的，都可以放在属性字段上
-
@Autowired通过bytype的方式实现，而且必须要求这个对象存在【常用】
-
@Resource默认通过byname的方式实现，如果找不到名字，则通过bytype实现，如果两个都找不到的情况下，就报错【常用】
-
执行顺序不同，@Autowired通过bytype的方式实现；@Resource默认通过byname的方式实现
8、使用注解开发
在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" 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/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <context:annotation-config/> </beans>
1.bean
2.属性如何注入
@Component
public class User {
@Value("fysyyds")
public String name;
}
3.衍生的注解
@Component有几个衍生注解，在我们web开发中，会按照mvc三层架构分层
-
dao【@Repository】
-
service 【@Service】
-
controller 【@Controller】
这四个注解功能都是一样的，都是代表将某个类注册到spring中，装配Bean
4.自动装配
5.作用域
@Controller
@Scope("prototype")
public class User {
@Value("fysyyds")
public String name;
}
6.小结
xml与注解：
-
xml更加万能，适用于任何场合，维护简单方便，
-
注解不是自己类是用不了，维护相对复杂
xml与注解最佳实践：
-
xml用来管理bean
-
注解只负责完成属性的注入
-
我们在使用的过程中，只需要注意一个问题：必须让注解生效，就要开启注解支持
<!--指定要扫描的包，这个包下的注解就会生效--> <context:component-scan base-package="com.twd"/> <context:annotation-config/>
9、使用java的方式配置Spring
现在我们完全不使用spring的xml配置了，全权交给java来做
JavaConfig是Spring的一个子项目，在Spring4之后，就变成了一个核心功能
实体类：
package com.twd.pojo;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class User {
private String name;
public String getName() {
return name;
}
@Value("twd")
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
配置类：
package com.twd.config;
import com.twd.pojo.User;
import org.springframework.beans.factory.annotation.Configurable;
import org.springframework.context.annotation.Bean;
@Configurable
public class TwdConfig {
@Bean
public User user(){
return new User();
}
}
测试类：
import com.twd.config.TwdConfig;
import com.twd.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class MyTest {
public static void main(String[] args) {
ApplicationContext context = new AnnotationConfigApplicationContext(TwdConfig.class);
User user = (User) context.getBean("user");
System.out.println(user.getName());
}
}
这种纯java的配置方式，在springboot项目中随处可见
10、AOP（代理模式）
为什么要学习代理模式？因为这就是SpringAOP的底层【springAOP和SpringMVC】
代理模式的分类：
-
静态代理
-
动态代理
10.1 静态代理
代理模式的好处：
-
可以是真实角色的操作更加纯粹，不用去关注一些公共的业务
-
公共业务就交给代理角色，实现了业务的分工
-
公共业务发生扩展的时候，方便集中管理
缺点
-
一个真实角色就会产生一个代理角色，代码会翻倍，效率变低
解决：动态代理
10.2 动态代理
-
动态代理和静态代理角色一样
-
动态代理的代理模式是动态生成的，不是我们直接写好的
-
动态代理分为两大类，基于接口的动态代理，基于类的动态代理
-
基于接口---JDK动态代理
-
基于类：cglib
-
java字节码实现：javasist
-
需要了解两个类：Proxy（代理），InvocationHandler（调用处理程序）
动态代理优点：
-
代理的是一个接口
-
一个动态代理可以代理多个类，是要是实现了一个接口即可
11、AOP
11.1 什么是AOP
AOP(Aspect Oriented Programming)意为:面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
11.2 使用Spring实现Aop
导入一个依赖包
<dependencies> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.4</version> </dependency> </dependencies>
方式一：使用spring的接口
方式二：自定义来实现AOP
方式三：使用注解实现
12、整合Mybatis
1.导入相关jar包
-
junit
-
mybatis
-
mysql数据库
-
spring相关的
-
aop织入
-
mybatis-spring【new】
<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/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.example</groupId> <artifactId>Spring-study</artifactId> <version>1.0-SNAPSHOT</version> </parent> <artifactId>spring-10-mybatis</artifactId> <name>Archetype - spring-10-mybatis</name> <url>http://maven.apache.org</url> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13.2</version> <scope>test</scope> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.33</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.16</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>5.2.0.RELEASE</version> </dependency> <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>6.1.8</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.4</version> </dependency> <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>3.0.3</version> </dependency> </dependencies> </project>
2.编写配置文件
3.测试
12.1 回忆Mybatis
mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <typeAliases> <package name="com.twd.pojo"/> </typeAliases> <environments default="development"> <environment id="development"> <transactionManager type="JDBC"/> <dataSource type="POOLED"> <property name="driver" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&userUnicode=true&characterEncoding=UTF-8"/> <property name="username" value="root"/> <property name="password" value="@twd20040401."/> </dataSource> </environment> </environments> <mappers> <mapper class="com.twd.mapper.UserMapper"/> </mappers> </configuration>
pom.xml
<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/maven-v4_0_0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.example</groupId> <artifactId>Spring-study</artifactId> <version>1.0-SNAPSHOT</version> </parent> <artifactId>spring-10-mybatis</artifactId> <name>Archetype - spring-10-mybatis</name> <url>http://maven.apache.org</url> <dependencies> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.13.2</version> <scope>test</scope> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.33</version> </dependency> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis</artifactId> <version>3.5.16</version> </dependency> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId> <version>6.0.7</version> </dependency> <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>6.1.8</version> </dependency> <dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <version>1.9.4</version> </dependency> <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring --> <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring</artifactId> <version>3.0.3</version> </dependency> <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok --> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.32</version> <scope>provided</scope> </dependency> </dependencies> <!-- 在build中配置resource，来防止我们资源导出失败的问题 --> <build> <resources> <resource> <directory>src/main/resources</directory> <includes> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>true</filtering> </resource> <resource> <directory>src/main/java</directory> <includes> <include>**/*.properties</include> <include>**/*.xml</include> </includes> <filtering>true</filtering> </resource> </resources> </build> </project>
Test
import com.twd.mapper.UserMapper;
import com.twd.pojo.User;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import javax.annotation.Resource;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class MyTest {
@Test
public void test() throws IOException {
String resources="mybatis-config.xml";
InputStream in = Resources.getResourceAsStream(resources);
SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(in);
SqlSession sqlSession = sessionFactory.openSession(true);
UserMapper mapper = sqlSession.getMapper(UserMapper.class);
List<User> users = mapper.selectUser();
for (User user : users) {
System.out.println(user);
}
sqlSession.close();
}
}
UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.twd.mapper.UserMapper"> <select id="selectUser" resultType="user"> select * from user; </select> </mapper>
12.2 Mybatis_spring
1.编写数据源配置
2.sqlSessionFactory
3.sqlSessionTemplate
4.需要给接口加实现类
5.将自己写的实现类，注入到spring中
6.测试使用
spring-dao.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/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"> <!-- DataSource:使用spring的数据源替换Mybatis的配置 c3p0 dbcp druid 我们这里使用spring提供的JDBC：org.springframework.jdbc.datasource--> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&userUnicode=true&characterEncoding=UTF-8"/> <property name="username" value="root"/> <property name="password" value="@twd20040401."/> </bean> <!-- sqlSessionFactory--> <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"/> <!-- 绑定mybatis配置文件--> <property name="configLocation" value="classpath:mybatis-config.xml"/> <property name="mapperLocations" value="classpath:com/twd/mapper/*.xml"/> </bean> <!-- SqlSessionTemplate:就是我们使用的sqlSession--> <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"> <!-- 只能使用构造器注入sqlSessionFactory，因为他没有set方法--> <constructor-arg index="0" ref="sqlSessionFactory"/> </bean> </beans>
mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd"> <configuration> <typeAliases> <package name="com.twd.pojo"/> </typeAliases> </configuration>
applicationcontext.xml
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/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"> <import resource="spring-dao.xml"/> <bean id="userMapper" class="com.twd.mapper.UserMapperImpl"> <property name="sqlSession" ref="sqlSession"/> </bean> </beans>
MyTest
import javax.annotation.Resource;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
public class MyTest {
@Test
public void test() throws IOException {
ApplicationContext context = new ClassPathXmlApplicationContext("applicationcontext.xml");
UserMapper userMapper = context.getBean("userMapper", UserMapper.class);
for (User user : userMapper.selectUser()) {
System.out.println(user);
}
}
}
简化操作
UserMapperImpl2
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper{
@Override
public List<User> selectUser() {
return getSqlSession().getMapper(UserMapper.class).selectUser();
}
}
13、声明式事务
13.1 事务回顾
-
要么都成功，要么都失败
-
事务十分重要，涉及到数据的一致性问题
-
保证完整性和一致性
事务的ACID原则：
-
原子性
-
一致性
-
隔离性
-
多个业务可能操作同一个资源，防止数据损坏
-
-
持久性
-
事务一旦提交，无论系统发生什么问题，都不会在被影响，被持久化的写到存储器中
-
13.2 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" xmlns:tx="http://www.springframework.org/schema/tx" 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 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd"> <!-- DataSource:使用spring的数据源替换Mybatis的配置 c3p0 dbcp druid 我们这里使用spring提供的JDBC：org.springframework.jdbc.datasource--> <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/> <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&userUnicode=true&characterEncoding=UTF-8"/> <property name="username" value="root"/> <property name="password" value="@twd20040401."/> </bean> <!-- sqlSessionFactory--> <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <property name="dataSource" ref="dataSource"/> <!-- 绑定mybatis配置文件--> <property name="configLocation" value="classpath:mybatis-config.xml"/> <property name="mapperLocations" value="classpath:com/twd/mapper/*.xml"/> </bean> <!-- SqlSessionTemplate:就是我们使用的sqlSession--> <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate"> <!-- 只能使用构造器注入sqlSessionFactory，因为他没有set方法--> <constructor-arg index="0" ref="sqlSessionFactory"/> </bean> <!--配置声明式事务--> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <constructor-arg ref="dataSource"/> </bean> <!-- 结合AOP实现事务的织入--> <!-- 配置事务通知--> <tx:advice id="txAdvice" transaction-manager="transactionManager"> <!-- 给方法配置事务--> <!-- 配置事务的传播特性：new propagation=--> <tx:attributes> <tx:method name="add" propagation="REQUIRED"/> <tx:method name="delete" propagation="REQUIRED"/> <tx:method name="query" read-only="true"/> <tx:method name="*" propagation="REQUIRED"/> </tx:attributes> </tx:advice> <!-- 配置事务切入--> <aop:config> <aop:pointcut id="txPointCut" expression="execution(* com.twd.mapper.*.*(..))"/> <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/> </aop:config> </beans>
-
编程式事务：需要在代码中配置管理
为什么需要事务
-
如果不配置事务，可能存在数据提交不一致情况
-
如果我们不在Spring中去配置声明式事务，就需要在代码中手动配置事务
-
事务在项目中的开发十分重要，涉及到数据的一致性和完整性问题
272
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
