「Spring」是指整个 Spring Framework 生态系统,而「Spring Framework」则是指 Spring 框架本身
Spring 技术是 JavaEE 开发必备技能,企业开发技术选型命中率 >90%
官网地址:https://spring.io/
Spring 发展到今天已经形成了一种开发的生态圈, Spring 提供了若干个项目,每个项目用于完成特定的功能,例如:web项目,微服务,分布式
Spring Framework:Spring框架是一个轻量级的框架,其核心原则是面向接口编程和控制反转(IoC),是Spring开发的基础架构,经常简称为Spring。
Spring Boot:Spring Boot 通过简化配置、提供开箱即用的功能和自动化配置,显著简化了基于 Spring 的应用程序的开发和部署流程,作用:简化Spring framework的开发,增加开发速度。
**Spring Cloud:**Spring Cloud 是一个用于构建分布式系统和微服务架构的开源框架集合。它基于Spring Framework,作用:并提供了一套完善的分布式系统解决方案。
总的来说Spring:基础架构,spring Boot:简化开发,spring Cloud 分布式微服务
内聚:是指程序内各个模块之间的紧密程度
耦合:是指各个外部程序之间的紧密程序
在Spring核心容器中的提供了解决方案IOC设计原则(思想)
使用对象时,在程序中不要主动使用new产生对象,转换为由==外部==提供对象
就是在不重新创建另外一个service服务类的情况下,BookDaoImp1与BookDaoImp2,两者的耦合度太高,调这个就不能调那个,所以就出现了控制反转这个东西,不new了直接从外部传过来对象,直接通过声明接口再接收实现类Bean对象就完了。
无论是直接修改代码还是使用依赖注入的方式来替换对象实现,都需要重新编译、打包和部署应用程序才能生效。但是,依赖注入可以让应用程序更加可扩展和易于维护。通过依赖注入,我们可以独立地开发和测试每个组件,而不必把所有代码放在一起进行开发和测试。这使得应用程序更加模块化,并且可以更容易地进行单元测试和集成测试,减少了开发人员的工作量和时间。
IOC(Inversion of Control)控制反转
Spring技术对IoC思想进行了实现
DI(Dependency Injection)依赖注入
目标:充分解耦
最终效果
【第一步】导入Spring坐标
【第二步】定义Spring管理的类(接口)
【第三步】创建Spring配置文件,配置对应类作为Spring管理的bean对象
【第四步】初始化IOC容器(Spring核心容器/Spring容器),通过容器获取bean对象
【第一步】导入Spring坐标
<dependencies>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>5.2.10.RELEASEversion>
dependency>
dependencies>
【第二步】定义Spring管理的类(接口)
public interface BookDao {
public void save();
}
public class BookDaoImpl implements BookDao {
public void save() {
System.out.println("book dao save ...");
}
}
public interface BookService {
public void save();
}
public class BookServiceImpl implements BookService {
private BookDao bookDao = new BookDaoImpl();
public void save() {
System.out.println("book service save ...");
bookDao.save();
}
}
【第三步】创建Spring配置文件,配置对应类作为Spring管理的bean对象
<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="bookDao" class="com.itheima.dao.imp1.BookDaoImp1">bean>
<bean id="bookService" class="com.itheima.service.imp1.BookServiceimp1">bean>
beans>
注意事项:bean定义时id属性在同一个上下文中(IOC容器中)不能重复
【第四步】初始化IOC容器(Spring核心容器/Spring容器),通过容器获取Bean对象
public class APP {
public static void main(String[] args) {
//1.创建IoC容器,加载spring核心配置文件
ApplicationContext cxt = new
ClassPathXmlApplicationContext("applicationContext.xml");
//2.从IOC容器中获取Bean对象(Bookservice对象)
BookService bookService = (BookService) cxt.getBean("bookService");
//3.调用Bean对象(BookService对象)的方法
bookService.save();
}
}
最终实现了从Spring(外部)中传入Bookserviceimp1对象,但是没有进行依赖注入,所以仍要在Bookserviceimp1中new BookDaoimp1对象,接下来我们引入DI,去解决这个数据层的问题
【第一步】删除使用new的形式创建对象的代码
【第二步】提供依赖对象对应的setter方法
【第三步】配置service与dao之间的关系
【第一步】删除使用new的形式创建对象的代码
public class BookServiceimp1 implements BookService {
private BookDao bookDao;
@Override
public void save() {
System.out.println("book service save...");
bookDao.save();
}
}
【第二步】提供依赖对象对应的setter方法
public class BookServiceimp1 implements BookService {
private BookDao bookDao;
@Override
public void save() {
System.out.println("book service save...");
bookDao.save();
}
public void setBookDao(BookDao bookDao) {
this.bookDao = bookDao;
}
}
【第三步】配置service与dao之间的关系
在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 http://www.springframework.org/schema/beans/spring-beans.xsd">
<bean id="bookDao" class="com.itheima.dao.imp1.BookDaoImp1">bean>
<bean id="bookService" class="com.itheima.service.imp1.BookServiceimp1">
<property name="bookDao" ref="bookDao">property>
bean>
beans>
执行顺序可以进一步澄清如下:
标签定义的 bookDao
Bean 时,会创建 bookDao
的实例。
标签定义的 bookService
Bean。在创建 bookService
的实例时,Spring 发现 bookService
类中定义了一个名为 bookDao
的属性,因此会调用 bookService
的 setBookDao()
方法。setBookDao()
方法时,Spring 将之前创建的 bookDao
实例作为参数传入,完成属性的注入。怎么识别的setter方法就是你要的setter呢?
set
开头,并且方法名后面跟着与name参数名相匹配的单词,set后面第一个单词得大写然后在name参数中填小写。 在依赖注入容器中,别名的作用是指定依赖项的标识符。当需要解析依赖项时,容器可以使用别名来定位并注入正确的依赖项实例。
在底层,依赖注入容器通常会维护一个依赖项注册表,其中包含依赖项类型与实例之间的映射关系。当我们使用别名配置依赖项时,实际上是在注册表中指定了该别名与特定依赖项类型之间的关联。
单例模式的作用:
Bean的是由默认空参数构造器构造的:
public class BookDaoImpl implements BookDao {
public BookDaoImpl() {
System.out.println("book dao constructor is running ....");
}
public void save() {
System.out.println("book dao save ...");
}
}
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl"/>
public class AppForInstanceBook {
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
BookDao bookDao = (BookDao) ctx.getBean("bookDao");
bookDao.save();
}
}
注意:无参构造方法如果不存在,将抛出异常BeanCreationException
另外:在找错误的时候自下而上的
public interface OrderDao {
public void save();
}
public class OrderDaoImpl implements OrderDao {
public void save() {
System.out.println("order dao save ...");
}
}
//静态工厂创建对象
public class OrderDaoFactory {
public static OrderDao getOrderDao(){
System.out.println("factory setup....");
return new OrderDaoImpl();
}
}
<bean id="orderDao" class="com.itheima.factory.OrderDaoFactory" factory-method="getOrderDao"/>
public class AppForInstanceOrder {
public static void main(String[] args) {
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
OrderDao orderDao = (OrderDao) ctx.getBean("orderDao");
orderDao.save();
}
}
public interface UserDao {
public void save();
}
public class UserDaoImpl implements UserDao {
public void save() {
System.out.println("user dao save ...");
}
}
//实例工厂创建对象
public class UserDaoFactory {
public UserDao getUserDao(){
return new UserDaoImpl();
}
}
<bean id="userFactory" class="com.itheima.factory.UserDaoFactory"/>
<bean id="userDao" factory-method="getUserDao" factory-bean="userFactory"/>
public class AppForInstanceUser {
public static void main(String[] args) {
//在没有修改前
// //创建实例工厂对象
// UserDaoFactory userDaoFactory = new UserDaoFactory();
// //通过实例工厂对象创建对象
// UserDao userDao = userDaoFactory.getUserDao();
// userDao.save();
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
UserDao userDao = (UserDao) ctx.getBean("userDao");
userDao.save();
}
}
UserDaoFactoryBean中实例化什么类型的对象泛型就是该类型。
//FactoryBean创建对象
public class UserDaoFactoryBean implements FactoryBean<UserDao> {
//代替原始实例工厂中创建对象的方法
public UserDao getObject() throws Exception {
return new UserDaoImpl();
}
/*
在 Spring 容器中,保存 Bean 的时候,它会先根据 getObjectType() 方法所返回的类型来先保存 Bean,这样就保证了从容器中根据 Bean 的类型获取对象时不会出错。如果不重写 getObjectType 方法,则Spring将无法确定创建的对象类型,需要通过显式配置Bean的类型来完成。
就是先创建这种类型预先存在容器中,你看其他的创建方式都是预先创建这种类型的对象的哦~,等要用的时候再再IOC容器中取
*/
public Class<?> getObjectType() {
return UserDao.class;
}
public boolean isSingleton(){
return false//false 为非单例模式 true 为单例 默认不写就是单例
}
}
<bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean"/>
使用之前的AppForInstanceUser测试类去运行看结果就行了。注意配置文件中id="userDao"是否重复。
说法错误,getObject()
方法内的默认实现返回的是一个UserDaoImpl
实例,意味着该工厂默认只能创建UserDaoImpl
类型的对象。
但这并不意味着该工厂只能创建这个对象,你可以根据实际需求在getObject()
方法内进行逻辑判断和处理,来返回不同的对象实例
*举个例子:*假设你有一个UserDaoFactoryBean
工厂类,用于创建UserDao
对象,但根据不同的环境(比如开发环境和生产环境),你想要创建不同类型的UserDao
实现类。
你可以在getObject()
方法内根据环境条件来创建不同的对象,如下所示:
public UserDao getObject() throws Exception {
if (isDevelopmentEnvironment()) {
return new UserDaoImplForDevelopment();
} else {
return new UserDaoImplForProduction();
}
}
public class BookDaoImpl implements BookDao {
public void save() {
System.out.println("book dao save ...");
}
//表示bean初始化对应的操作
public void init(){
System.out.println("init...");
}
//表示bean销毁前对应的操作
public void destory(){
System.out.println("destory...");
}
}
<bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory"/>
public class AppForLifeCycle {
public static void main( String[] args ) {
//此处需要使用实现类类型,接口类型没有close方法
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
BookDao bookDao = (BookDao) ctx.getBean("bookDao");
bookDao.save();
//注册关闭钩子函数,在虚拟机退出之前回调此函数,关闭容器
ctx.registerShutdownHook();
//关闭容器
//ctx.close();
}
}
对于主动销毁容器的操作有两种:(容器关闭前触发bean的销毁)
ConfigurableApplicationContext
接口close()
操作ConfigurableApplicationContext
接口registerShutdownHook()
操作public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
private BookDao bookDao;
public void setBookDao(BookDao bookDao) {
System.out.println("set .....");
this.bookDao = bookDao;
}
public void save() {
System.out.println("book service save ...");
bookDao.save();
}
public void destroy() throws Exception {
System.out.println("service destroy");
}
//这个是初始化的方法,在set之后的意思,确保能调用set后的参数
public void afterPropertiesSet() throws Exception {
System.out.println("service init");
}
}
setter注入
构造器注入
前文用的就是setter注入引用类型,比较常用
<bean id="ServiceImp1" class="com.itheima.service.imp.ServiceImp1">
<property name="DaoImp1" ref="DaoImp1"></property>
</bean>
private dao Dao;
public void setDaoImp1(dao dao) {
Dao = dao;
}
//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
ServiceImp1 service = (ServiceImp1) cxt.getBean("ServiceImp1");
//3.调用bean
service.save();
<bean id="ServiceImp1" class="com.itheima.service.imp.ServiceImp1">
<property name="connectionNum" value="3"></property>
</bean>
private int connectionNum;
public void setConnectionNum(int connectionNum) {
this.connectionNum = connectionNum;
}
//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
ServiceImp1 service = (ServiceImp1) cxt.getBean("ServiceImp1");
//3.调用bean
service.save();
结果:
<bean id="ServiceImp1" class="com.itheima.service.imp.ServiceImp1">
<constructor-arg name="dao" ref="DaoImp1">constructor-arg>
bean>
//在name里面传的是形参名字,有耦合性,那边改这边就得改
private dao dao;
public ServiceImp1(dao dao) {
this.dao = dao;
}
//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
ServiceImp1 service = (ServiceImp1) cxt.getBean("ServiceImp1");
//3.调用bean
service.save();
<bean id="ServiceImp1" class="com.itheima.service.imp.ServiceImp1">
<constructor-arg name="connectionNum" value="3">constructor-arg>
bean>
//在name里面传的是形参名字,有耦合性,那边改这边就得改
private int connectionNum;
public ServiceImp1(int connectionNum) {
this.connectionNum = connectionNum;
}
//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
ServiceImp1 service = (ServiceImp1) cxt.getBean("ServiceImp1");
//3.调用bean
service.save();
private dao dao;
private int connectionNum;
public ServiceImp1(int connectionNum,dao dao) {
this.connectionNum = connectionNum;
this.dao = dao;
}
1. 使用类型进行传递
<bean id="ServiceImp1" class="com.itheima.service.imp.ServiceImp1">
<constructor-arg type="int" value="3">constructor-arg>
<constructor-arg type="com.itheima.dao.dao" ref="DaoImp1">constructor-arg>
bean>
//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
ServiceImp1 service = (ServiceImp1) cxt.getBean("ServiceImp1");
//3.调用bean
service.save();
缺点:如果参数里有两个类型一样的也难搞
2.使用indx进行传递
<bean id="ServiceImp1" class="com.itheima.service.imp.ServiceImp1">
<constructor-arg index="0" value="3">constructor-arg>
<constructor-arg index="1" ref="DaoImp1">constructor-arg>
bean>
//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
ServiceImp1 service = (ServiceImp1) cxt.getBean("ServiceImp1");
//3.调用bean
service.save();
概念:IoC容器根据bean所依赖的资源在容器中自动查找并注入到bean中的过程称为自动装配,基本数据类型不可装配
方式:1.按类型(常用),2.按名称,3.按构造方法,4.不启用自动装配
仅介绍按类型与按名称
必须要有setter,是在配置文件中找实现类class,不加id也能运行
<bean id="ServiceImp1" class="com.itheima.service.imp.ServiceImp1" autowire="byType"/>
<bean id="DaoImp1" class="com.itheima.dao.imp.DaoFactoryBean">bean>
private dao dao;
public void setDao(dao dao) {
this.dao = dao;
}
//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
ServiceImp1 service = (ServiceImp1) cxt.getBean("ServiceImp1");
//3.调用bean
service.save();
必须要有setter,根据id的名与set方法后面首字母小写一致才可以,有耦合不建议使用
<bean id="ServiceImp1" class="com.itheima.service.imp.ServiceImp1" autowire="byName"/>
<bean id="dao" class="com.itheima.dao.imp.DaoFactoryBean">bean>
//根据id的名与set方法后面首字母小写一致才可以,有耦合不建议使用
private dao dao;
public void setDao(dao dao) {
this.dao = dao;
}
//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
ServiceImp1 service = (ServiceImp1) cxt.getBean("ServiceImp1");
//3.调用bean
service.save();
<property name="array">
<array>
<value>100value>
<value>200value>
<value>300value>
array>
property>
<property name="list">
<list>
<value>itcastvalue>
<value>itheimavalue>
<value>boxueguvalue>
<value>chuanzhihuivalue>
list>
property>
<property name="set">
<set>
<value>itcastvalue>
<value>itheimavalue>
<value>boxueguvalue>
<value>boxueguvalue>
set>
property>
<property name="map">
<map>
<entry key="country" value="china"/>
<entry key="province" value="henan"/>
<entry key="city" value="kaifeng"/>
map>
property>
<property name="properties">
<props>
<prop key="country">chinaprop>
<prop key="province">henanprop>
<prop key="city">kaifengprop>
props>
property>
说明:property标签表示setter方式注入,构造方式注入constructor-arg标签内部也可以写
、 、
、
<bean id="ServiceImp2" class="com.itheima.service.ServiceImp2">
<property name="array">
<array>
<value>123value>
<value>345value>
<value>567value>
array>
property>
<property name="list">
<list>
<value>123value>
<value>345value>
<value>567value>
list>
property>
<property name="set">
<set>
<value>牛value>
<value>牛value>
<value>牛value>
set>
property>
<property name="mp">
<map>
<entry key="牛" value="2">entry>
<entry key="牛" value="2">entry>
<entry key="牛" value="2">entry>
map>
property>
<property name="properties">
<props>
<prop key="牛">2prop>
<prop key="牛">2prop>
<prop key="牛">2prop>
props>
property>
bean>
public class ServiceImp2 implements service{
private int[] array;
private List<Integer> list;
private Set<String> set;
private Map<String,Integer> mp;
private Properties properties;
public void setArray(int[] array) {
this.array = array;
}
public void setList(List<Integer> list) {
this.list = list;
}
public void setSet(Set<String> set) {
this.set = set;
}
public void setMp(Map<String, Integer> mp) {
this.mp = mp;
}
public void setProperties(Properties properties) {
this.properties = properties;
}
public void save(){
System.out.println("array:"+Arrays.toString(array));
System.out.println("list:"+list);
System.out.println("set:"+set);
System.out.println("mp:"+mp);
System.out.println("pro:"+properties);
}
}
//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt = new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
ServiceImp2 service = (ServiceImp2) cxt.getBean("ServiceImp2");
//3.调用bean
service.save();
结果:
一开始找DataSource导入类
再通过ctrl+f12看是通过构造器注入还是setter注入
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/spring_db"/>
<property name="username" value="root"/>
<property name="password" value="1234"/>
bean>
//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt =
new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
DataSource dataSource = (DataSource)cxt.getBean("dataSource");
//3.使用bean
System.out.println(dataSource);
一开始找DataSource导入类
再通过ctrl+f12看是通过构造器注入还是setter注入
<bean class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"/>
<property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring_db"/>
<property name="user" value="root"/>
<property name="password" value="1234"/>
bean>
//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt =
new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
DataSource dataSource = (DataSource)cxt.getBean("dataSource");
//3.使用bean
System.out.println(dataSource);
但是一般来说这种外部资源的导入参数都在配置properties文件中:
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db
jdbc.username=root
jdbc.password=1234
//1.创建ioc容器实现ioc思想
ClassPathXmlApplicationContext cxt =
new ClassPathXmlApplicationContext("applicationContext.xml");
//2.创建bean
DataSource dataSource = (DataSource)cxt.getBean("dataSource");
//3.使用bean
System.out.println(dataSource);
这里有坑可能会有与系统相同的属性名,而系统的优先级大于配置文件导致出错,
<context:property-placeholder location="jdbc.properties" system-properties-mode="NEVER"/>
<context:property-placeholder location="jdbc.properties,msg.properties"/>
<context:property-placeholder location="*.properties"/>
<context:property-placeholder location="classpath:*.properties"/>
<context:property-placeholder location="classpath*:*.properties"/>
问题:按照Bean名称获取Bean有什么弊端,按照Bean类型获取Bean有什么弊端?
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
ApplicationContext ctx = new FileSystemXmlApplicationContext("D:\\applicationContext.xml");
ApplicationContext ctx = new ClassPathXmlApplicationContext("bean1.xml", "bean2.xml");
弊端:需要自己强制类型转换
BookDao bookDao = (BookDao) ctx.getBean("bookDao");
弊端:推荐使用
BookDao bookDao = ctx.getBean("bookDao", BookDao.class);
弊端:如果IOC容器中同类型的Bean对象有多个,此处获取会报错
BookDao bookDao = ctx.getBean(BookDao.class);
Resource resources = new ClassPathResource("applicationContext.xml");
BeanFactory bf = new XmlBeanFactory(resources);
BookDao bookDao = bf.getBean("bookDao", BookDao.class);
bookDao.save();
原因:xml配置Bean对象有些繁琐,使用注解简化Bean对象的定义
总的来说:
bean- --》注解表示
配置文件 —》配置类表示
原:
转为:
@Component("ServiceImp1")
public class ServiceImp1 implements service {
private dao dao;
public void setDao(dao dao) {
this.dao = dao;
}
@Override
public void save() {
System.out.println("serviceimp1...");
//System.out.println("connectionNum=="+connectionNum);
dao.save();
}
}
那配置文件怎么访问到呢?通过配置扫描器,扫描某个报下的所有类有没有这个注解
xml:
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:context="http://www.springframework.org/schema/context"
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
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<context:component-scan base-package="com.itheima"/>
beans>
Spring提供**@Component
**注解的三个衍生注解
@Controller
:用于表现层bean定义@Service
:用于业务层bean定义@Repository
:**用于数据层bean定义配置文件也好麻烦呢,去掉变成一个配置类吧
原XML文件:
转为配置类:
@Configuration
public class SpringConfig {
}
加上扫描器注解
@Configuration
@ComponentScan("com.itheima")
//可追加@ComponentScan({"com.itheima.service","com.itheima.dao"})
public class SpringConfig {
}
@Component("ServiceImp1")
public class ServiceImp1 implements service {
private dao dao;
public void setDao(dao dao) {
this.dao = dao;
}
@Override
public void save() {
System.out.println("serviceimp1...");
//System.out.println("connectionNum=="+connectionNum);
dao.save();
}
}
@Configuration
@ComponentScan("com.itheima")
//可追加@ComponentScan({"com.itheima.service","com.itheima.dao"})
public class SpringConfig {
}
public class App {
public static void main(String[] args) {
//1.利用注解类创建ioc容器实现ioc思想
AnnotationConfigApplicationContext cxt =
new AnnotationConfigApplicationContext(SpringConfig.class);
//2.创建bean
ServiceImp1 serviceImp1 = (ServiceImp1)cxt.getBean("ServiceImp1");
serviceImp1.save();
}
}
@Repository
@Scope("singleton")//非单例prototype
public class BookDaoImpl implements BookDao {
}
@Repository
@Scope("singleton")
public class BookDaoImpl implements BookDao {
public BookDaoImpl() {
System.out.println("book dao constructor ...");
}
@PostConstruct
public void init(){
System.out.println("book init ...");
}
}
@Repository
@Scope("singleton")
public class BookDaoImpl implements BookDao {
public BookDaoImpl() {
System.out.println("book dao constructor ...");
}
@PreDestroy
public void destroy(){
System.out.println("book destory ...");
}
}
注意:@PostConstruct和@PreDestroy注解是jdk中提供的注解,从jdk9开始,jdk中的javax.annotation包被移除了,也就是说这两个注解就用不了了,可以额外导入一下依赖解决这个问题。
<dependency>
<groupId>javax.annotationgroupId>
<artifactId>javax.annotation-apiartifactId>
<version>1.3.2version>
dependency>
应用 ”自动装配“ 注解去配置依赖**@Autowired注解**默认按类型
不需要构造函数的原因:
自动装配基于反射设计创建对象并暴力反射对应属性为私有属性初始化数据,因此无需提供setter方法。
@Service
public class BookServiceImpl implements BookService {
//@Autowired:注入引用类型,自动装配模式,默认按类型装配
@Autowired
private BookDao bookDao;
public void save() {
System.out.println("book service save ...");
bookDao.save();
}
}
说明:不管是使用配置文件还是配置类,都必须进行对应的Spring注解包扫描才可以使用。@Autowired默认按照类型自动装配,如果IOC容器中同类的Bean有多个,那么默认按照变量名和Bean的名称匹配,建议使用@Qualifier注解指定要装配的bean名称
解决:IOC容器中同类型Bean有多个装配哪一个的问题
@Service
public class BookServiceImpl implements BookService {
//@Autowired:注入引用类型,自动装配模式,默认按类型装配
@Autowired
//@Qualifier:自动装配bean时按bean名称装配
@Qualifier("bookDao")
private BookDao bookDao;
public void save() {
System.out.println("book service save ...");
bookDao.save();
}
}
注意:@Qualifier注解无法单独使用,必须配合@Autowired注解使用
@Repository("bookDao")
public class BookDaoImpl implements BookDao {
//@Value:注入简单类型(无需提供set方法)
@Value("sunshuo")
private String name;
public void save() {
System.out.println("book dao save ..." + name);
}
}
@Repository("bookDao")
public class BookDaoImpl implements BookDao {
//@Value:注入简单类型(无需提供set方法)
@Value("${name}")
private String name;
public void save() {
System.out.println("book dao save ..." + name);
}
}
@Configuration
@ComponentScan("com.itheima")
//@PropertySource加载properties配置文件
@PropertySource({"classpath:jdbc.properties"}) //{}可以省略不写
public class SpringConfig {
}
注意:@PropertySource()中加载多文件请使用数组格式配置,不允许使用通配符*
public class JdbcConfig {
//@Bean:表示当前方法的返回值是一个bean对象,添加到IOC容器中
@Bean
public DataSource dataSource(){
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName("com.mysql.jdbc.Driver");
ds.setUrl("jdbc:mysql://localhost:3306/spring_db");
ds.setUsername("root");
ds.setPassword("root");
return ds;
}
}
@Configuration
@ComponentScan("com.itheima")
//@Import:导入配置信息
@Import({JdbcConfig.class})
public class SpringConfig {
}
@Configuration
@ComponentScan({"com.itheima.config","com.itheima.service","com.itheima.dao"}) //只要com.itheima.config包扫到了就行,三个包可以合并写成com.itheima
public class SpringConfig {
}
public class JdbcConfig {
//1.定义一个方法获得要管理的对象
@Value("com.mysql.jdbc.Driver")
private String driver;
@Value("jdbc:mysql://localhost:3306/spring_db")
private String url;
@Value("root")
private String userName;
@Value("root")
private String password;
//2.@Bean:表示当前方法的返回值是一个bean对象,添加到IOC容器中
@Bean
public DataSource dataSource(){
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName(driver);
ds.setUrl(url);
ds.setUsername(userName);
ds.setPassword(password);
return ds;
}
}
说明:如果@Value()中使用了EL表达式读取properties属性文件中的内容,那么就需要加载properties属性文件。
@Bean
public DataSource dataSource(BookDao bookDao){
System.out.println(bookDao);
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName(driver);
ds.setUrl(url);
ds.setUsername(userName);
ds.setPassword(password);
return ds;
}
说明:引用类型注入只需要为bean定义方法设置形参即可,容器会根据类型自动装配对象
DataSource
的 Bean 的时候,发现它依赖于类型为 bookDao
bookDao
类型匹配的 Bean。bookDao
自动注入到DataSource
Bean 的形参中。Spring会自动从IOC容器中找到BookDao对象赋值给参数bookDao变量,如果没有就会报错。
//@Configuration 配置xml类
//@Component:工具类
//@Controller:用于表现层bean定义
//@Service:用于业务层bean定义
//@Repository:用于数据层bean定义
//@PostConstruct:起始
//@PreDestroy:销毁
//@Scope("singleton")//非单例prototype
//@Autowired:引用类
//@Qualifier:引用id
//@Value:简单类
//@PropertySource({"classpath:jdbc.properties"}):加载prop配置
//@Bean:第三方bean导入到ioc中
//@Import:将含第三方bean的类导入到此类中
连接对象是由factory得到的紧接着接下来操作,所以核心对象是sqlSessionFactory对象
我们的目标就是通过spring创建此bean
public interface BrandMapper {
//查询所有
@Select("select * from tb_brand")
List selectAll();
}
@Service
public class BrandService implements service{
@Autowired
private BrandMapper brandMapper;//(爆红正常,在创建时才能看见bean)
@Override
public void save() {
}
@Override
public List selectAll() {
return brandMapper.selectAll();
}
}
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-jdbcartifactId>
<version>5.2.10.RELEASEversion>
dependency>
<dependency>
<groupId>org.mybatisgroupId>
<artifactId>mybatis-springartifactId>
<version>1.3.0version>
dependency>
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?useSSL=false
jdbc.username=root
jdbc.password=root
public class JdbcConfig {
@Value("${jdbc.driver}")
private String driver;
@Value("${jdbc.url}")
private String url;
@Value("${jdbc.username}")
private String userName;
@Value("${jdbc.password}")
private String password;
@Bean
public DataSource dataSource(){
DruidDataSource ds = new DruidDataSource();
ds.setDriverClassName(driver);
ds.setUrl(url);
ds.setUsername(userName);
ds.setPassword(password);
return ds;
}
}
public class MybatisConfig {
//定义bean,SqlSessionFactoryBean,用于产生SqlSessionFactory对象
@Bean
public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
ssfb.setTypeAliasesPackage("com.itheima.domain");
ssfb.setDataSource(dataSource);
return ssfb;
}
//定义bean,返回MapperScannerConfigurer对象,就是Mapper对象
@Bean
public MapperScannerConfigurer mapperScannerConfigurer(){
MapperScannerConfigurer msc = new MapperScannerConfigurer();
msc.setBasePackage("com.itheima.dao");
return msc;
}
}
@Configuration
@ComponentScan("com.itheima")
//@PropertySource:加载类路径jdbc.properties文件
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}
测试
public class App {
public static void main(String[] args) {
//1.利用注解类创建ioc容器实现ioc思想
AnnotationConfigApplicationContext cxt =
new AnnotationConfigApplicationContext(spring_config.class);
//2.拿出bean
BrandService bean = cxt.getBean(BrandService.class);
System.out.println(bean.selectAll());
}
}
SqlSessionFactoryBean
:Spring 会通过 @Bean
注解标识的方法,创建一个 SqlSessionFactoryBean
对象,并将其添加到Spring容器中。SqlSessionFactoryBean
需要一个数据源(DataSource
)来设置数据库连接。Spring 会根据已有的数据源的配置或者创建新的数据源对象,并将其注入到 SqlSessionFactoryBean
中。SqlSessionFactory
:Spring 容器会调用 SqlSessionFactoryBean
对象的方法,创建一个 SqlSessionFactory
对象。这个对象包含了 MyBatis 的配置信息和对数据库的访问能力。SqlSession
:通过 SqlSessionFactory
创建一个 SqlSession
对象,用于执行数据库操作。这个 SqlSession
包含了与数据库的连接和一个完整的事务上下文。MapperScannerConfigurer
:类似于 SqlSessionFactoryBean
的创建,通过 @Bean
注解创建一个 MapperScannerConfigurer
对象,并将其添加到Spring容器中。MapperScannerConfigurer
会扫描指定的包路径下的 Mapper 接口,并将其注册为 Spring 的 bean。这样,就可以通过依赖注入的方式,在业务代码中使用 Mapper 接口。SqlSessionFactory
和 Mapper
对象,可以将其注入到业务代码中进行使用。什么?你说看不到Sqlssion的创建和不知道mapper怎么与sqlssion产生联系的?
在使用 Spring Boot 集成 MyBatis 时,我们不需要显式地创建 SqlSession
对象,也不需要手动与 Mapper 建立联系。这是因为 Spring Boot 整合 MyBatis 的自动化配置已经帮助我们完成了这些工作。
具体来说,Spring Boot 在创建 SqlSessionFactory
对象时,会自动创建一个由 Spring 管理的 SqlSessionTemplate
对象。SqlSessionTemplate
是 SqlSession
接口的实现类,它封装了对数据库的各种操作方法。
而在 Spring Boot 创建 Mapper 接口时,会使用默认的代理方式将 Mapper 接口与 SqlSessionTemplate
进行关联。这样,当我们注入 Mapper 接口时,实际上注入的是一个代理对象,该代理对象在执行方法时会使用 SqlSessionTemplate
调用相应的数据库操作。
因此,我们不需要手动创建 SqlSession
对象,并且 Mapper 接口与 SqlSession
的关联由 Spring Boot 在背后自动完成。我们只需要在需要使用 Mapper 的地方使用 @Autowired
注解即可,Spring Boot 会负责将 Mapper 对象注入到我们的代码中,使我们可以直接调用 Mapper 的方法进行数据库操作。
1.导相关包
2.创建数据源,就是数据库连接池对象
3.创建MybatisConfig整合mybatis
4.spring扫描其他配置类
<dependency>
<groupId>junitgroupId>
<artifactId>junitartifactId>
<version>4.12version>
dependency>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-testartifactId>
<version>5.1.9.RELEASEversion>
dependency>
@RunWith(SpringJUnit4ClassRunner.class)//类加载器
@ContextConfiguration(classes = {spring_config.class}) //加载配置类
public class BrandService {
@Autowired
private BrandMapper brandMapper;
@Test
public void select(){
System.out.println(brandMapper.selectAll());
}
}
}
注意:junit的依赖至少要是4.12版本,可以是4.13等版本,否则出现如下异常:
UserServiceTest
类上使用 @RunWith(SpringJUnit4ClassRunner.class)
注解,指定使用 Spring 提供的 JUnit 运行器来运行测试类。UserServiceTest
类上使用 @ContextConfiguration(classes = {spring_config.class})
注解,指定 Spring 配置类的位置,告诉 Spring Test 加载配置类并创建 Spring 应用上下文。1.导包
2.在test中新建一个测试类
3.指定使用 Spring 提供的 JUnit 运行器来运行测试类。
4.指定 Spring 配置类的位置
5.可以注入,然后进行使用
一种编程范式,指导开发者如何组织程序结构
AOP(Aspect Oriented Programming)面向切面编程
OOP(Object Oriented Programming)面向对象编程
在不惊动原始设计的基础上为其进行功能增强。简单的说就是在不改变方法源代码的基础上对方法进行功能增强。
无入侵式/无侵入式
**连接点:**正在执行的方法,例如:update()、delete()、select()等都是连接点。
切入点(Pointcut):进行功能增强了的方法,例如:update()、delete()方法,select()方法没有被增强所以不是切入点,但是是连接点。增强是指用AOP增加了功能。
在SpringAOP中,一个切入点可以只描述一个具体方法,也可以匹配多个方法
(1)一个具体方法:com.itheima.dao包下的BookDao接口中的无形参无返回值的save方法
(2)匹配多个方法:所有的save方法,所有的get开头的方法,所有以Dao结尾的接口中的任意方法,所有带有一个参数的方法
**通知(Advice):**在切入点前后执行的操作,也就是增强的共性功能,在SpringAOP中,功能最终以方法的形式呈现
**通知类:**通知方法所在的类叫做通知类
**切面(Aspect):**描述通知与切入点的对应关系,也就是指定哪些通知方法对应哪些切入点方法。
<dependencies>
<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-contextartifactId>
<version>5.2.10.RELEASEversion>
dependency>
<dependency>
<groupId>org.aspectjgroupId>
<artifactId>aspectjweaverartifactId>
<version>1.9.4version>
dependency>
dependencies>
public interface dao {
public void save();
public void delet();
}
@Repository("DaoImp1")
public class DaoImp1 implements dao{
@Override
public void save() {
System.out.println("DaoImp1...");
}
@Override
public void delet(){
System.out.println("delet...");
}
}
//通知类必须配置成Spring管理的bean
@Component
public class MyAdvice {
public void method(){
System.out.println(System.currentTimeMillis());
}
}
@Component//实例化bean
@Aspect//设置当前类为切面类
public class MyAdvice {
//设置切入点,@Pointcut注解要求配置在方法上方
@Pointcut("execution(void com.itheima.dao.imp.DaoImp1.delet())")
private void pt(){}
//设置在切入点pt()的前面运行当前操作(前置通知)
@Before("pt()")
public void method(){
System.out.println(System.currentTimeMillis());
}
}
@Configuration
@ComponentScan("com.itheima")
//开启注解开发AOP功能
@EnableAspectJAutoProxy
public class SpringConfig {
}
public class App {
public static void main(String[] args) {
//1.利用注解类创建ioc容器实现ioc思想
AnnotationConfigApplicationContext cxt =
new AnnotationConfigApplicationContext(spring_config.class);
//2.拿出bean
dao bean = cxt.getBean(dao.class);
bean.delet();
System.out.println(bean.getClass());
}
}
1.开启注解开发AOP功能
2.定义通知类,写通知方法
3.设置切入点
4.绑定切入点和通知(切面)
获取bean执行方法
目标对象(Target):被代理的对象,也叫原始对象,该对象中的方法没有任何功能增强。
代理对象(Proxy):代理后生成的对象,由Spring帮我们创建代理对象,也就是加上增强后的对象。
execution(void com.itheima.dao.BookDao.update())
execution(void com.itheima.dao.impl.BookDaoImpl.update())
动作关键字(访问修饰符 返回值 包名.类/接口名.方法名(参数) 异常名)
execution(public User com.itheima.service.UserService.findById(int))
目的:可以使用通配符描述切入点,快速描述。
匹配com.itheima包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法
execution(public * com.itheima.*.UserService.find*(*))
匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法
execution(public User com..UserService.findById(..))
execution(* *..*Service+.*(..))
@Before("pt()")
public void before() {
System.out.println("before advice ...");
}
@After("pt()")
public void after() {
System.out.println("after advice ...");
}
@AfterReturning("pt()")
public void afterReturning() {
System.out.println("afterReturning advice ...");
}
@AfterThrowing("pt()")
public void afterThrowing() {
System.out.println("afterThrowing advice ...");
}
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
System.out.println("around before advice ...");
Object ret = pjp.proceed();
System.out.println("around after advice ...");
return ret;
}
环绕通知注意事项
@Around("ProjectAdvice.servicePt()") //本类类名可以省略不写
public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
//获取执行的签名对象
Signature signature = pjp.getSignature();
//获取接口/类全限定名
String className = signature.getDeclaringTypeName();
//获取方法名
String methodName = signature.getName();
}
说明:在前置通知和环绕通知中都可以获取到连接点方法的参数们
**方法一:**JoinPoint对象
@Before("pt()")
public void before(JoinPoint jp) {
Object[] args = jp.getArgs(); //获取连接点方法的参数们
System.out.println(Arrays.toString(args));
}
**方法二:**ProccedJointPoint对象(是JoinPoint的子类)
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
Object[] args = pjp.getArgs(); //获取连接点方法的参数们
System.out.println(Arrays.toString(args));
Object ret = pjp.proceed();
return ret;
}
**注:**另外Object ret = pjp.proceed(arg []);
中可以传入一个参数数组,篡改原始方法的参数
可使用:
方法一:@AfterReturning
@AfterReturning(value = "pt()",returning = "ret")
public void afterReturning(String ret) { //变量名要和returning="ret"的属性值一致
System.out.println("afterReturning advice ..."+ret);
}
==注意:==如果在形参位置ProceedingJoinPoint pjp和String ret同时存在,那么必须先写pjp
方法二:@Around(“pt()”):环绕通知中可以手工书写对原始方法的调用,得到的结果即为原始方法的返回值
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) throws Throwable {
// 手动调用连接点方法,返回值就是连接点方法的返回值
Object ret = pjp.proceed();
return ret;
}
说明:在抛出异常后通知和环绕通知中都可以获取到连接点方法中出现的异常
方法一:@AfterThrowing:抛出异常后通知可以获取切入点方法中出现的异常信息,使用形参可以接收对应的异常对象
@AfterThrowing(value = "pt()",throwing = "t")
public void afterThrowing(Throwable t) {//变量名要和throwing = "t"的属性值一致
System.out.println("afterThrowing advice ..."+ t);
}
方法二:@Around(“pt()”):抛出异常后通知可以获取切入点方法运行的异常信息,使用形参可以接收运行时抛出的异常对象
@Around("pt()")
public Object around(ProceedingJoinPoint pjp) {
Object ret = null;
//此处需要try...catch处理,catch中捕获到的异常就是连接点方法中抛出的异常
try {
ret = pjp.proceed();
} catch (Throwable t) {
t.printStackTrace();
}
return ret;
}
需求:任意业务层接口执行均可显示其执行效率(执行时长)
分析:
①:业务功能:业务层接口执行前后分别记录时间,求差值得到执行效率
②:通知类型选择前后均可以增强的类型——环绕通知
@Component
@Aspect
public class ProjectAdvice {
//匹配业务层的所有方法
@Pointcut("execution(* com.itheima.service.*Service.*(..))")
private void servicePt(){}
//设置环绕通知,在原始操作的运行前后记录执行时间
@Around("ProjectAdvice.servicePt()") //本类类名可以省略不写
public void runSpeed(ProceedingJoinPoint pjp) throws Throwable {
//获取执行的签名对象
Signature signature = pjp.getSignature();
//获取接口/类全限定名
String className = signature.getDeclaringTypeName();
//获取方法名
String methodName = signature.getName();
//记录开始时间
long start = System.currentTimeMillis();
//执行万次操作
for (int i = 0; i < 10000; i++) {
pjp.proceed();
}
//记录结束时间
long end = System.currentTimeMillis();
//打印执行结果
System.out.println("万次执行:"+ className+"."+methodName+"---->" +(end-start) + "ms");
}
}
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
@EnableAspectJAutoProxy //开启AOP注解功能
public class SpringConfig {
}
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class AccountServiceTestCase {
@Autowired
private AccountService accountService;
@Test
public void testFindById(){
Account account = accountService.findById(2);
}
@Test
public void testFindAll(){
List<Account> list = accountService.findAll();
}
}
注意点:每一次调用该方法都是一次重新连接重新创建mapper对象所有如果在text输出也就输出一次,注意mybatis配置要配置正确
需求:因为在百度网盘有的时候,密码可能含有空格导致无法登录
//-------------service层代码-----------------------
public interface ResourcesService {
public boolean openURL(String url ,String password);
}
@Service
public class ResourcesServiceImpl implements ResourcesService {
@Autowired
private ResourcesDao resourcesDao;
public boolean openURL(String url, String password) {
return resourcesDao.readResources(url,password);
}
}
//-------------dao层代码-----------------------
public interface ResourcesDao {
boolean readResources(String url, String password);
}
@Repository
public class ResourcesDaoImpl implements ResourcesDao {
public boolean readResources(String url, String password) {
System.out.println(password.length());
//模拟校验
return password.equals("root");
}
}
@Component
@Aspect
public class DataAdvice {
@Pointcut("execution(boolean com.itheima.service.*Service.*(*,*))")
private void servicePt(){}
@Around("DataAdvice.servicePt()")
public Object trimStr(ProceedingJoinPoint pjp) throws Throwable {
Object[] args = pjp.getArgs();
for (int i = 0; i < args.length; i++) {
//判断参数是不是字符串
if(args[i].getClass().equals(String.class)){
args[i] = args[i].toString().trim();
}
}
Object ret = pjp.proceed(args);
return ret;
}
}
@Configuration
@ComponentScan("com.itheima")
@EnableAspectJAutoProxy
public class SpringConfig {
}
public class App {
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
ResourcesService resourcesService = ctx.getBean(ResourcesService.class);
boolean flag = resourcesService.openURL("http://pan.baidu.com/haha", "root ");
System.out.println(flag);
}
}
@Update("update tb_brand set ordered = ordered + #{order} where id = #{id}")
void inMoney(@Param("id") int id,@Param("order") int order);
@Update("update tb_brand set ordered = ordered - #{order} where id = #{id}")
void outMoney(@Param("id") int id,@Param("order") int order);
@Override
public void transfer(int inid, int outid, int tranOrder) {
brandMapper.outMoney(outid,tranOrder);
int b = 1/0;
brandMapper.inMoney(inid,tranOrder);
}
只有出没有进~
不变,同成功同失败
public interface service {
@Transactional
void transfer(int inid, int outid, int tranOrder);
}
Spring注解式事务通常添加在业务层接口中而不会添加到业务层实现类中,降低耦合
在jdbc中配置
//配置事务管理器,mybatis使用的是jdbc事务
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource){
DataSourceTransactionManager dtm = new DataSourceTransactionManager();
dtm.setDataSource(dataSource);
return dtm;
}
因为最后每个sql语句都是每个事务,而最终要做到同成功同失败,那么就需要将每个事务融合成一个事务,而这些事务的联系就是通过jdbc的dataSouce
@Configuration
@ComponentScan("com.itheima")
@PropertySource("classpath:jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
//开启注解式事务驱动
@EnableTransactionManagement
public class SpringConfig {
}
说明:
对于RuntimeException类型异常或者Error错误,Spring事务能够进行回滚操作
但是对于编译器异常,Spring事务是不进行回滚的,所以需要使用rollbackFor来设置要回滚的异常。
public interface service {
@Transactional(rollbackFor = {IOException.class})
void transfer(int inid, int outid, int tranOrder);
}
如果有一个需求,无论其他两个事务成功与否,这个事务都要执行,那么就不能将此事务与其他事务进行融合,利用事务传播行为进行分离
**事务传播行为:**事务协调员对事务管理员所携带事务的处理态度
public interface LogService {
//propagation设置事务属性:传播行为设置为当前操作需要新事务
@Transactional(propagation = Propagation.REQUIRES_NEW)
void log(String out, String in, Double money);
}