Spring入门笔记-深入浅出
Spring
Spring简介
Spring框架是由于软件开发的复杂性而创建的。
Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。
Spring的用途不仅仅限于服务器端的开发。
Spring的优点
- Spring是一个开源免费的框架
- Spring是一个轻量级的框架，非侵入式
- 控制反转IOC，面向切面AOP
- 支持事务支持和对框架的支持
Spring是一个轻量级的控制反转（IOC）和面向切面（AOP）的容器（框架）
Spring依赖
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webmvcartifactId>
<version>5.2.5.RELEASEversion>
dependency>
Spring IOC本质
控制反转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）。
所谓的ioc就是对象由spring来创建，管理，装配
IOC创建对象的方式
-
使用无参构造创建对象，默认
-
使用有参构造对象
-
下标赋值
<bean id="user" class="com.fwh.pojo.User"> <constructor-arg index="0" value="aaa">constructor-arg> bean> -
通过类型创建
<bean id="user" class="com.fwh.pojo.User"> <constructor-arg type="java.lang.String" value="fwh">constructor-arg> bean> -
直接通过参数名来设置
<bean id="user" class="com.fwh.pojo.User"> <constructor-arg name="name" value="fwh">constructor-arg> bean>
-
在配置文件加载的时候，容器中的管理的对象就已经初始化了！
Spring配置说明
Bean的配置
<bean id="userT" class="com.fwh.pojo.UserT" name="userT2 userT3 userT4">
<property name="name" value="fwh">property>
bean>
别名
<alias name="user" alias="new user">alias>
import
一般用于团队开发，它可以将多个配置文件导入合并为一个，使用的时候直接使用总配置就可以了
依赖注入
构造器注入
看IOC创建对象的方式
set方式注入
Student类
public class Student {
private String name;
private Address address;
private String[] books;
private List<String> hobbys;
private Map<String, String> card;
private Set<String> games;
private String wife;
private Properties info;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public String[] getBooks() {
return books;
}
public void setBooks(String[] books) {
this.books = books;
}
public List<String> getHobbys() {
return hobbys;
}
public void setHobbys(List<String> hobbys) {
this.hobbys = hobbys;
}
public Map<String, String> getCard() {
return card;
}
public void setCard(Map<String, String> card) {
this.card = card;
}
public Set<String> getGames() {
return games;
}
public void setGames(Set<String> games) {
this.games = games;
}
public String getWife() {
return wife;
}
public void setWife(String wife) {
this.wife = wife;
}
public Properties getInfo() {
return info;
}
public void setInfo(Properties info) {
this.info = info;
}
@Override
public String toString() {
return "Student{" +
"name='" + name + '\'' +
", address=" + address +
", books=" + Arrays.toString(books) +
", hobbys=" + hobbys +
", card=" + card +
", games=" + games +
", wife='" + wife + '\'' +
", info=" + info +
'}';
}
}
Address类
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 + '\'' +
'}';
}
}
XML配置
<bean id="address" class="com.fwh.entity.Address"/>
<bean id="student" class="com.fwh.entity.Student">
<property name="name" value="fwh">property>
<property name="address" ref="address">property>
<property name="books">
<array>
<value>aaavalue>
<value>bbbvalue>
<value>cccvalue>
<value>dddvalue>
array>
property>
<property name="hobbys">
<list>
<value>aaavalue>
<value>bbbvalue>
<value>cccvalue>
list>
property>
<property name="card">
<map>
<entry key="aaa" value="AAA"/>
<entry key="bbb" value="BBB"/>
<entry key="ccc" value="CCC"/>
map>
property>
<property name="games">
<set>
<value>aaavalue>
<value>bbbvalue>
<value>cccvalue>
set>
property>
<property name="wife">
<null/>
property>
<property name="info">
<props>
<prop key="aaa">AAAprop>
<prop key="bbb">BBBprop>
props>
property>
bean>
拓展方式注入
使用p命名空间和c命名空间进行注入
xmlns:p="http://www.springframework.org/schema/p"
xmlns:c="http://www.springframework.org/schema/c"
p命名空间
<bean id="user" class="com.fwh.pojo.UserT" p:name="fwh">bean>
c命名空间
<bean id="user" class="com.fwh.pojo.User" c:name="fwh">bean>
注意点：p命名空间和c命名空间不能直接使用，需要导入xml约束
bean作用域
-
单例模式(Spring默认的机制)
<bean id="accountService" class="com.something.DefaultAccountService" scope="singleton"/> -
原型模式：每次容器从容器中get的时候，都会产生一个新对象
<bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/> -
其余的request，session，application这些只能在web开发中应用
bean的自动装配
自动装配是Spring满足bean依赖一种方式
Spring会在上下文中自动寻找，并启动给bean装配属性
在Spring中有三种装配方式
- 在xml中显示的配置
- 在java中显示配置
- 隐式的自动装配bean
ByName自动装配
<bean id="people" class="com.fwh.pojo.People" autowire="byName">
<property name="name" value="qaz">property>
bean>
ByType自动装配
<bean id="people" class="com.fwh.pojo.People" autowire="byType">
<property name="name" value="qaz">property>
bean>
小结
byName的时候，需要保证所有bean的id唯一，并且这个bean需要和自动注入的属性的set方法的值一致
byType的时候，需要保证所有bean的class唯一，并且这个bean需要和自动注入的属性的类型一致
使用注解实现自动装配
导入约束
配置注解的支持
<context:annotation-config>context:annotation-config>
使用@Autowired注解
@Autowired
private Cat cat;
@Autowired
private Dog dog;
如果@Autowired自动装配的环境复杂，自动装配无法通过一个注解@Autowired完成的时候，我们可以使用@Qualifier（value=“xxx”）去配置@Autowired的使用，指定一个唯一的bean对象注入！
@Resource和@Autowired区别
- 都是用来自动装配的，都可以放在属性字段上
- @Autowired通过byType的方式来实现的，而且必须要求这个对象存在
- @Resource默认通过byName的方式来实现的，如果找不到名字，则通过byType实现，如果两个都找不到的情况下，就报错！
注解
@Autowired
自动装配通过类型。名字
如果@Autowired不能唯一自动装配上属性，则需要通过@Qualifier（value=“xxx”）去配置@Autowired的使用
@Nullable
字段标记了这个注解，说明这个字段可以为null
@Resource
自动装配通过名字。类型
@Component
组件，放在类上，说明这个类被Spring管理了，就是bean
@Component的衍生注解
@Component的几个衍生注解，在web开发中会按照mvc三层架构分层
- dao【@Repository】
- service【@Service】
- controller【@Controller】
这四个注解功能是一样的，都是代表将某个类注册到Spring中，装配Bean
@Scope
作用域
使用注解开发
在Spring4之后，要使用注解开发，必须保证aop的包导入
xml与注解：
- xml更万能，适合所有场合，维护方便
- 注解不是自己类使用不了，维护相对复杂
xml与注解最佳时间：
- xml用来管理bean
- 注解只负责完成属性的注入
- 在使用过程中，必须让注解生效，就需要开启注解支持
使用JAVA的方式配置Spring
完全不使用Spring的xml配置，全权交给JAVA来做！
JavaConfig是Spring的一个子项目，在Spring4之后，它成为了一个核心功能！
User类：
package com.fwh.pojo;
import org.springframework.beans.factory.annotation.Value;
public class User {
private String name;
public String getName() {
return name;
}
//@Value：属性注入值
@Value("qaz")
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
'}';
}
}
SpringConfig类
package com.fwh.config;
import com.fwh.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
//Spring容器托管，注册到容器中，因为本来就是一个@Component
//@Configuration代表这是一个配置类，就像beans.xml
@Configuration
public class SpringConfig {
//注册一个bean，相当于写一个bean标签
//方法的名字相当于bean标签中的id属性
//方法的返回值相当于bean标签中的class属性
@Bean
public User getUser() {
return new User();
}
}
测试类
import com.fwh.config.SpringConfig;
import com.fwh.pojo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class MyTest {
public static void main(String[] args) {
//如果完全使用配置类方式去做，我们只能通过AnnoationConfig上下文获取容器，通过配置类的class对象加载
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class);
User user = (User) applicationContext.getBean("getUser");
System.out.println(user.getName());
}
}
静态代理
角色分析：
- 抽象角色：一般会使用接口或者抽象类来解决
- 真实角色：被代理的角色
- 代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
- 客户：访问代理对象的人
接口：
// 租房
public interface Rent {
public void rent();
}
真实角色：
//房东
public class Host implements Rent{
@Override
public void rent(){
System.out.println("房东要出租房子！");
}
}
代理模式：
//代理
public class Proxy implements Rent {
private Host host;
public Proxy() {
}
public Proxy(Host host) {
this.host = host;
}
@Override
public void rent() {
seeHouse();
host.rent();
hetong();
fare();
}
//看房
public void seeHouse() {
System.out.println("中介带你看房");
}
//签合同
public void hetong(){
System.out.println("签合同");
}
// 收中介费
public void fare() {
System.out.println("收中介费");
}
}
客户端访问代理模式
//客户
public class Client {
public static void main(String[] args) {
//房东出租房子
Host host = new Host();
//代理，中介帮找房子，只不过代理一般会有一些附属的操作
Proxy proxy = new Proxy(host);
//不用面对房东，直接找中介租房即可
proxy.rent();
}
}
代理模式的好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的任务
- 公共也就交给代理角色！实现了业务分工！
- 公共任务发生扩展的时候，方便集中管理
代理模式缺点：
- 一个真实角色就会产生一个代理角色，代码量会翻倍，开发效率更低
实战
接口：
public interface UserService {
public void add();
public void delete();
public void update();
public void query();
}
真实对象
//真实对象
public class UserServiceImpl implements UserService {
@Override
public void add() {
System.out.println("增加了一个用户");
}
@Override
public void delete() {
System.out.println("删除了一个用户");
}
@Override
public void update() {
System.out.println("修改了一个用户");
}
@Override
public void query() {
System.out.println("查询了一个用户");
}
}
代理模式
public class UserServiceProxy implements UserService {
UserServiceImpl userService;
public void setUserService(UserServiceImpl userService) {
this.userService = userService;
}
@Override
public void add() {
log("add");
userService.add();
}
@Override
public void delete() {
log("delete");
userService.delete();
}
@Override
public void update() {
log("update");
userService.update();
}
@Override
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.add();
}
}
动态代理
- 动态代理和静态代理角色一样
- 动态代理的代理类是动态生成的，不是写好的
- 动态代理分为两大类：基于接口的动态代理，基于类的动态代理
- 基于接口：JDK动态代理
- 基于类：cglib
- java字节码实现：javasist
接口：
// 租房
public interface Rent {
public void rent();
}
真实对象
//房东
public class Host implements Rent {
@Override
public void rent(){
System.out.println("房东要出租房子！");
}
}
代理模式
//自动生成代理类
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);
}
//处理代理实例，并返回结果
@Override
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 proxyInvocationHandler = new ProxyInvocationHandler();
//通过调用程序处理角色来处理我们要调用的接口对象！
proxyInvocationHandler.setRent(host);
//这里的proxy就是动态生成的
Rent proxy = (Rent) proxyInvocationHandler.getProxy();
proxy.rent();
}
}
实战
生成动态代理工具类
package demo04;
import demo03.Rent;
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);
}
//处理代理实例，并返回结果
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
log(method.getName());
//动态代理的本质，就是使用反射机制实现
Object result = method.invoke(target, args);
return result;
}
//日志方法
public void log(String msg) {
System.out.println("[debug] 使用了" + msg + "方法");
}
}
客户端访问代理对象
package demo04;
import demo02.UserService;
import demo02.UserServiceImpl;
import demo03.Host;
import demo03.Rent;
public class Client {
public static void main(String[] args) {
//真实角色
UserServiceImpl userService = new UserServiceImpl();
//代理角色
ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
//设置要代理的对象
proxyInvocationHandler.setTarget(userService);
//动态生成代理类
UserService proxy = (UserService) proxyInvocationHandler.getProxy();
proxy.query();
}
}
动态代理的好处：
- 可以使真实角色的操作更加纯粹！不用去关注一些公共的任务
- 公共也就交给代理角色！实现了业务分工！
- 公共任务发生扩展的时候，方便集中管理
- 一个动态代理类代理的是一个接口，一般就是对应的一类业务
- 一个动态代理类可以代理多个子类，只要是实现了同一个接口即可
AOP
什么是AOP
AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
AOP在Spring中的作用
提供声明式事务；允许用户自定义切面
- 横切关注点：跨越应用程序多模块的方法或功能。既是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志，安全，缓存，事务等等
- 切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类
- 通知(Advice)：切面必须完成的工作。即，它是类中的方法
- 目标(Target)：被通知的对象
- 代理(Proxy)：向目标对象应用通知之后创建的对象
- 切入点(PointCut)：切面通知执行的“地点”的定义
- 连接点(JointPoint)：与切入点匹配的执行点
使用Spring实现AOP
导入依赖包
<dependency>
<groupId>org.aspectjgroupId>
<artifactId>aspectjweaverartifactId>
<version>1.9.4version>
dependency>
实现方式一：使用Spring的API接口
写接口
public interface UserService {
public void add();
public void delete();
public void update();
public void query();
}
实现类
public class UserServiceImpl implements UserService{
@Override
public void add() {
System.out.println("增加了一个用户");
}
@Override
public void delete() {
System.out.println("删除了一个用户");
}
@Override
public void update() {
System.out.println("修改了一个用户");
}
@Override
public void query() {
System.out.println("查询了一个用户");
}
}
配置文件
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd"
>
<bean id="userService" class="com.fwh.service.UserServiceImpl">bean>
<bean id="log" class="com.fwh.log.Log">bean>
<bean id="afterLog" class="com.fwh.log.AfterLog">bean>
<aop:config>
<aop:pointcut id="pointCut" expression="execution(* com.fwh.service.UserServiceImpl.*(..))"/>
<aop:advisor advice-ref="log" pointcut-ref="pointCut">aop:advisor>
<aop:advisor advice-ref="afterLog" pointcut-ref="pointCut">aop:advisor>
aop:config>
beans>
测试类
public class Mytest {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//动态代理代理的是接口
UserService userService = applicationContext.getBean("userService", UserService.class);
userService.add();
}
}
实现方式二：自定义来实现AOP
自定义一个类
public class DiyPointCut {
public void before() {
System.out.println("=============方法执行前=============");
}
public void after(){
System.out.println("==============方法执行后==================");
}
}
配置文件
<bean id="diy" class="com.fwh.diy.DiyPointCut">bean>
<aop:config>
<aop:aspect ref="diy">
<aop:pointcut id="point" expression="execution(* com.fwh.service.UserServiceImpl.*(..))"/>
<aop:before method="before" pointcut-ref="point">aop:before>
<aop:after method="after" pointcut-ref="point">aop:after>
aop:aspect>
aop:config>
测试
public class Mytest {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//动态代理代理的是接口
UserService userService = applicationContext.getBean("userService", UserService.class);
userService.add();
}
实现方式三：使用注解
注解类
package com.fwh.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;
@Aspect//标注这个类是一个切面
public class AnnotationPointCut {
@Before("execution(* com.fwh.service.UserServiceImpl.*(..))")
public void before() {
System.out.println("=============方法执行前=============");
}
@After("execution(* com.fwh.service.UserServiceImpl.*(..))")
public void after() {
System.out.println("==============方法执行后==================");
}
//在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
@Around("execution(* com.fwh.service.UserServiceImpl.*(..))")
public void around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("环绕前");
//执行方法
Object proceed = joinPoint.proceed();
System.out.println("环绕后");
}
}
配置文件
<bean id="annotationPointCut" class="com.fwh.diy.AnnotationPointCut">bean>
<aop:aspectj-autoproxy>aop:aspectj-autoproxy>
测试
public class Mytest {
public static void main(String[] args) {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
//动态代理代理的是接口
UserService userService = applicationContext.getBean("userService", UserService.class);
userService.add();
}
}
整合Mybaits
Mybatis-Spring
MyBatis-Spring 会帮助你将 MyBatis 代码无缝地整合到 Spring 中。它将允许 MyBatis 参与到 Spring 的事务管理之中，创建映射器 mapper 和 SqlSession 并注入到 bean 中，以及将 Mybatis 的异常转换为 Spring 的 DataAccessException。最终，可以做到应用代码不依赖于 MyBatis，Spring 或 MyBatis-Spring。
依赖
<dependencies>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatisartifactId>
<version>3.4.6version>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
<version>8.0.15version>
dependency>
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.12version>
<scope>testscope>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-webmvcartifactId>
<version>5.2.5.RELEASEversion>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-jdbcartifactId>
<version>5.2.5.RELEASEversion>
dependency>
<dependency>
<groupId>org.aspectjgroupId>
<artifactId>aspectjweaverartifactId>
<version>1.9.4version>
dependency>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatis-springartifactId>
<version>2.0.3version>
dependency>
dependencies>
User实体类
package com.fwh.entity;
public class User {
private int id;
private String name;
private String password;
public User() {
}
public User(int id, String name, String password) {
this.id = id;
this.name = name;
this.password = password;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
", password='" + password + '\'' +
'}';
}
}
UserMapper接口
package com.fwh.mapper;
import com.fwh.entity.User;
import java.util.List;
public interface UserMapper {
List<User> getUserList();
}
mybaits配置文件
<configuration>
configuration>
Spring-mapper配置文件
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop.xsd
">
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver">property>
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=ture&charaterEncoding=UTF-8&serverTimezone=GMT
">property>
<property name="username" value="root">property>
<property name="password" value="root">property>
bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource">property>
<property name="configLocation" value="classpath:mybatis-config.xml">property>
<property name="mapperLocations" value="classpath:mapper/UserMapper.xml">property>
bean>
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg index="0" ref="sqlSessionFactory">constructor-arg>
bean>
beans>
appliContext配置文件
<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-mapper.xml">import>
<bean id="userMapper" class="com.fwh.mapper.UserMapperImpl">
<property name="sqlSessionTemplate" ref="sqlSession">property>
bean>
<bean id="userMapper2" class="com.fwh.mapper.UserMapperImpl2">
<property name="sqlSessionFactory" ref="sqlSessionFactory">property>
bean>
beans>
测试
import com.fwh.entity.User;
import com.fwh.mapper.UserMapper;
import com.fwh.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;
public class UserMapperTest {
@Test
public void getUserList() {
SqlSession sqlSession = MybatisUtils.getSqlSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> userList = userMapper.getUserList();
for (User user : userList) {
System.out.println(user);
}
sqlSession.close();
}
@Test
public void selectUser() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
UserMapper userMapper = applicationContext.getBean("userMapper2", UserMapper.class);
for (User user : userMapper.getUserList()) {
System.out.println(user);
}
}
}
SqlSessionTemplate模板实现
package com.fwh.mapper;
import com.fwh.entity.User;
import org.mybatis.spring.SqlSessionTemplate;
import java.util.List;
//使用SqlSessionTemplate模板
public class UserMapperImpl implements UserMapper {
private SqlSessionTemplate sqlSessionTemplate;
public void setSqlSessionTemplate(SqlSessionTemplate sqlSessionTemplate) {
this.sqlSessionTemplate = sqlSessionTemplate;
}
public List<User> getUserList() {
UserMapper userMapper = sqlSessionTemplate.getMapper(UserMapper.class);
return userMapper.getUserList();
}
}
SqlSessionDaoSupport实现
package com.fwh.mapper;
import com.fwh.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> getUserList() {
SqlSession sqlSession = getSqlSession();
UserMapper userMapper =sqlSession.getMapper(UserMapper.class);
return userMapper.getUserList();
}
}
声明式事务
事务
- 把一组业务当成一个业务来做，要么成功，要么失败
- 事务在项目开发中，十分重要，涉及到数据一致性的问题
- 确保完整性和一致性
事务的ACID
- 原子性
- 一致性
- 隔离性
- 多个业务可能操作同一个资源，防止数据损坏
- 持久性
- 事务一旦提交，无论系统发生什么问题，结果都不会再被影响，被持久化写到存储器中
Spring中的事务管理
- 声明式事务：AOP
- 编程式事务：需要在代码中，进行事务管理
为什么需要事务
- 如果不配置事务，可能存在数据提交不一致的情况
- 如果不在Spring中配置声明式事务，我们需要在代码手动配置事务
- 事务在项目的开发中非常重要，涉及到数据一致性和完整性问题
事务的配置文件
<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">
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver">property>
<property name="url"
value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=ture&charaterEncoding=UTF-8&serverTimezone=GMT
">property>
<property name="username" value="root">property>
<property name="password" value="root">property>
bean>
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource">property>
<property name="configLocation" value="classpath:mybatis-config.xml">property>
<property name="mapperLocations" value="classpath:mapper/*.xml">property>
bean>
<bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
<constructor-arg index="0" ref="sqlSessionFactory">constructor-arg>
bean>
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<constructor-arg 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="delete" 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.fwh.mapper.*.*(..))"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut">aop:advisor>
aop:config>
beans>