spring(IOC,DI,AOP)详解

最新推荐文章于 2023-03-25 14:03:19 发布

集合，到我这里来

最新推荐文章于 2023-03-25 14:03:19 发布

阅读量348

点赞数

本文链接：https://blog.csdn.net/qq_43370419/article/details/104446910

版权

第一章-Spring概述

Spring介绍
概述：Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。
框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。
简单来说，Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。
一站式:Spring提供了三层解决方案.

Spring 的发展历程
1997 年 IBM 提出了 EJB 的思想
1998 年， SUN 制定开发标准规范 EJB1.0
1999 年， EJB1.1 发布
2001 年， EJB2.0 发布
2003 年， EJB2.1 发布
2006 年， EJB3.0 发布
Rod Johnson（spring 之父）
Expert One-to-One J2EE Design and Development(2002),阐述了 J2EE 使用 EJB 开发设计的优点及解决方案
Expert One-to-One J2EE Development without EJB(2004),阐述了 J2EE 开发不使用 EJB 的解决方式（Spring 雏形）
2017 年 9 月份发布了 spring 的最新版本 spring 5.0 通用版（GA）

Spring的优点
1.方便解耦，简化开发
通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。
2.AOP编程的支持
通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。
3.声明式事务的支持
在Spring中，我们可以从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活地进行事务的管理，提高开发效率和质量。
4.方便程序的测试
可以用非容器依赖的编程方式进行几乎所有的测试工作，在Spring里，测试不再是昂贵的操作，而是随手可做的事情。例如：Spring对Junit4支持，可以通过注解方便的测试Spring程序。
5.方便集成各种优秀框架
Spring不排斥各种优秀的开源框架，相反，Spring可以降低各种框架的使用难度，Spring提供了对各种优秀框架（如Struts,Hibernate、Hessian、Quartz）等的直接支持。
6.降低Java EE API的使用难度
Spring对很多难用的Java EE API（如JDBC，JavaMail，远程调用等）提供了一个薄薄的封装层，通过Spring的简易封装，这些Java EE API的使用难度大为降低。

Spring的体系结构
在这里插入图片描述

第二章-IOC

程序的耦合
耦合性(Coupling)，也叫耦合度，是对模块间关联程度的度量。耦合的强弱取决于模块间接口的复杂性、调用模块的方式以及通过界面传送数据的多少。模块间的耦合度是指模块之间的依赖关系，包括控制关系、调用关系、数据传递关系。模块间联系越多，其耦合性越强，同时表明其独立性越差( 降低耦合性，可以提高其独立性)。耦合性存在于各个领域，而非软件设计中独有的，但是我们只讨论软件工程中的耦合。

自定义IOC(工厂模式解耦)

原始方式
- 方式: 创建类, 直接根据类new对象
- 优点: 好写, 简单
- 缺点: 耦合度太高, 不好维护
接口方式
- 方式: 定义接口, 创建实现类. 接口=子类的对象
- 优点: 耦合度相对原始方式减低了一点
- 缺点: 多写了接口, 还是需要改源码不好维护
自定义IOC
- 方式: 使用对象的话, 不直接new()了,直接从工厂里面取; 不需要改变源码
- 思路：
  在实际开发中我们可以把三层的对象都使用配置文件配置起来，当启动服务器应用加载的时候，让一个类中的方法通过读取配置文件，把这些对象创建出来并存起来。在接下来的使用的时候，直接拿过来用就好了。那么，这个读取配置文件，创建和获取三层对象的类就是工厂
  添加坐标依赖：

<dependencies>
    <!-- 解析 xml 的 dom4j -->
    <dependency>
      <groupId>dom4j</groupId>
      <artifactId>dom4j</artifactId>
      <version>1.6.1</version>
    </dependency>
    <!-- dom4j 的依赖包 jaxen -->
    <dependency>
      <groupId>jaxen</groupId>
      <artifactId>jaxen</artifactId>
      <version>1.1.6</version>
    </dependency>
    <!--单元测试-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.10</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

IOC概述
IOC(inversion of control)的中文解释是“控制反转”，对象的使用者不是创建者. 作用是将对象的创建反转给spring框架来创建和管理。
控制反转怎么去理解呢。其实它反转的是什么呢，是对象的创建工作。举个例子:平常我们在servlet或者service里面创建对象，都是使用new 的方式来直接创建对象，现在有了spring之后，我们就再也不new对象了，而是把对象创建的工作交给spring容器去维护。我们只需要问spring容器要对象即可
ioc 的作用：削减计算机程序的耦合(解除我们代码中的依赖关系)。
配置文件详解(Bean标签)：

<?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标签: 注册bean, 把对象交给Spring管理
        1.【掌握】属性:
            id/name属性: 随便写,作为bean的唯一标识,不要重复(建议写接口的名字,首字母小写)
            class属性:  类的全限定名
            scope属性:  singleton 单例,  不管获得多少次 都是同一个, 创建出来存到Spring容器里面  【默认】
                        prototype 多例,  每获得一次 就创建一个新的对象,创建出来不会存到Spring容器里面

                        request 把创建的对象存到request域,针对web项目【了解】
                        session 把创建的对象存到session域,针对web项目【了解】
                        我们一般也是单例的, 特殊情况才是设置为prototype多例 eg:struts2里面的action
       2. 【了解】的属性
            init-method属性: 指定初始化方法,写方法名
            destroy-method属性: 指定销毁的方法, 象征着当前对象从Spring容器里面移除了 写方法名
    -->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl" scope="prototype"
        init-method="initMethod" destroy-method="destoryMethod"
    ></bean>

</beans>

id/name属性
用于标识bean ，其实id 和 name都必须具备唯一标识，两种用哪一种都可以。但是一定要唯一、一般开发中使用id来声明.
class属性: 用来配置要实现化类的全限定名
scope属性: 用来描述bean的作用范围
singleton: 默认值，单例模式。spring创建bean对象时会以单例方式创建。(默认)，使用的都是同一个对象(同一个id获得的). 单例的bean存到Spring容器里面
prototype: 多例模式。spring创建bean对象时会以多例模式创建。使用的不是同一个对象(同一个id获得的), 使用一个创建一个. 多例的bean不会存到Spring容器里面
request: 针对Web应用。spring创建对象时，会将此对象存储到request作用域。
session: 针对Web应用。spring创建对象时，会将此对象存储到session作用域。
init-method属性：spring为bean初始化提供的回调方法
destroy-method属性：spring为bean销毁时提供的回调方法. 销毁方法针对的都是单例bean ，如果想销毁bean , 可以关闭工厂
bean的作用范围和生命周期
单例对象： scope=“singleton”
一个应用只有一个对象的实例。它的作用范围就是整个引用。
生命周期：
对象出生：当应用加载，创建容器时，对象就被创建了。
对象活着：只要容器在，对象一直活着。
对象死亡：当应用卸载，销毁容器时，对象就被销毁了。
多例对象： scope=“prototype”
每次访问对象时，都会重新创建对象实例。
生命周期：
对象出生：当使用对象时，创建新的对象实例。
对象活着：只要对象在使用中，就一直活着。
对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了.
spring 中工厂的类结构图
ClassPathXmlApplicationContext：它是从类的根路径下加载配置文件
FileSystemXmlApplicationContext：它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
AnnotationConfigApplicationContext:当我们使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。
BeanFactory 和 ApplicationContext 的区别
新旧工厂
新工厂: 在工厂初始化的话的时候, 就会创建配置的所有的单例bean,存到Spring容器里面
旧工厂(已经废弃了): 等用到对象的时候, 再创建
ApplicationContext 是现在使用的工厂

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

XmlBeanFactory是老版本使用的工厂,目前已经被废弃【了解】

BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));

两者的区别:
ApplicationContext加载方式是框架启动时就开始创建所有单例的bean,存到了容器里面
BeanFactory加载方式是用到bean时再加载(目前已经被废弃)
实例化Bean的三种方式【了解】
方式一:无参构造方法方式
需要实例化的类，提供无参构造方法
配置代码

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>

方式二:静态工厂方式
需要额外提供工厂类，工厂方法是静态方法

public class StaticFactory {
	public static Object getBean(){
		return new AccountServiceImpl02();
	}
}

配置代码

<!--方式二:静态工厂方式  -->	
<bean  id="accountService02" class="com.itheima.utils.StaticFactory" factory-method="getBean"/>

方式三:实例工厂实例化的方法
创建实例化工厂类

public class InstanceFactory {
	public Object getBean(){
		return new AccountServiceImpl03();
	}
}

配置

<!-- 方式三: 实例化工厂 -->
<!--注册工厂  -->
<bean id="factory" class="com.itheima.utils.InstanceFactory"></bean>
<!--引用工厂  -->
<bean  id="accountService03" factory-bean="factory" factory-method="getBean"/>

一般情况下不会使用第二和三种, 主要使用第一种

第三章-依赖注入（DI）

依赖注入全称是 dependency Injection 翻译过来是依赖注入.其实就是如果我们托管的某一个类中存在属性，需要spring在创建该类实例的时候，顺便给这个对象里面的属性进行赋值。这就是依赖注入。
现在, Bean的创建交给Spring了, 需要在xml里面进行注册
我们交给Spring创建的Bean里面可能有一些属性(字段), Spring帮我创建的同时也把Bean的一些属性(字段)给赋值, 这个赋值就是注入.

注册: 把bean的创建交给Spring
依赖注入: bean创建的同时, bean里面可能有一些字段需要赋值, 这个赋值交给Spring, 这个过程就是依赖注入
构造方法方式注入
set方法方式的注入
P名称空间注入
SpEL的属性注入

构造方法方式注入【掌握】

Java代码

public class AccountServiceImpl implements AccountService {
    private String name;
    public AccountServiceImpl(String name) {
        this.name = name;
    }
    @Override
    public void save() {
        System.out.println("AccountServiceImpl... save()"+name);

    }
}

配置文件

<!--注册AccountService-->
 <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
    <constructor-arg name="name" value="张三"></constructor-arg>
</bean>

set方法方式的注入【重点】
注入简单类型

java代码

public class AccountServiceImpl implements AccountService {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void save() {
        System.out.println("AccountServiceImpl... save()"+name);

    }
}

配置文件

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
       <property name="name" value="李四"></property>
</bean>

注入数组类型

java代码

public class AccountServiceImpl implements AccountService {
    private String[] hobbys;

    public void setHobbys(String[] hobbys) {
        this.hobbys = hobbys;
    }

    @Override
    public void save() {
        System.out.println("AccountServiceImpl... save()"+ Arrays.toString(hobbys));

    }
}

配置文件

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
        <property name="hobbys">
            <array>
                <value>篮球</value>
                <value>足球</value>
                <value>乒乓球</value>
                <value>排球</value>
            </array>
        </property>
    </bean>

注入Map类型

Java代码

public class AccountServiceImpl implements AccountService {
    private Map<String,String> map;

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    @Override
    public void save() {
        Set<Map.Entry<String, String>> set = map.entrySet();
        for (Map.Entry<String, String> entry : set) {
            System.out.println(entry.getKey()+":"+entry.getValue());
        }
        System.out.println("AccountServiceImpl... save()");

    }
}

配置文件

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
     <property name="map">
         <map>
              <entry key="akey" value="aaa"/>
              <entry key="bkey" value="bbb"/>
              <entry key="ckey" value="ccc"/>
         </map>
     </property>
</bean>
或者

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
    <property name="map">
		<props>
			<prop key="akey">aaa</prop>
			<prop key="bkey">bbb</prop>
			<prop key="ckey">ccc</prop>
		</props>
	</property>
</bean>

注入Java对象类型

Java代码

   public class AccountServiceImpl implements AccountService {
          private AccountDao accountDao;
      
          public void setAccountDao(AccountDao accountDao) {
              this.accountDao = accountDao;
          }
          @Override
          public void save() {
      
              System.out.println("AccountServiceImpl... save()");
              accountDao.save();
      
          }
      }

配置文件

<!--注册AccountService-->
<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
    <property name="accountDao" ref="accountDao"></property>
</bean>
<!--注册accountDao-->
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
</bean>

名称空间注入【了解】
p名称空间的方式

提供属性的set方法
在applicationContext.xml引入p命名空间xmlns:p=“http://www.springframework.org/schema/p”

<?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:p="http://www.springframework.org/schema/p"
       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">
</beans>

使用

<bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl" p:name="张三">
  	
</bean>

Spring3.0之后 SpEL的属性注入【了解】
这种方式是使用spring 提供的一种表达式方式去赋值，如果是给前面提过的几个类型注入赋值，那么使用spEL 表达式来注入赋值倒显得繁琐。但是这个spEL 方式赋值，最大的好处在于，它能像EL表达式一般，在里面进行运算、逻辑判断,还可以调用其它Bean的属性和方法给当前属性赋值

语法格式： #{spEL}
类中存在一个属性 name , 并且给定 set方法。

  <property name="name" value="#{'张三'}" ></property>

小结

构造方法方式
- 定义变量 ,提供构造方法
- 在bean标签里面配置子标签constructor-arg

   <bean id="" class="">
   	<constructor-arg name="" value=""></constructor-arg>
   	<constructor-arg name="" ref=""></constructor-arg>
   </bean>

Set方法方式
- 2.1 步骤
  - 定义变量 ,提供Set方法
  - bean标签里面配置子标签property
- 2.2 简单类型(基本类型, String)

   <bean id="" class="">
   	<property name="" value=""></property>
   </bean>

2.3 数组类型

   <bean id="" class="">
   	<property name="">
   		<array>
   			<value></value>
   		</array>
   	</property>
   </bean>

2.3 Map类型

   <bean id="" class="">
   	<property name="">
   		<map>
   			<entry key="" value=""></entry>
   		</map>
   	</property>
   </bean>

2.4 对象类型

   <bean id="" class="">
   	<property name="" ref="">
   	</property>
   </bean>

使用Spring的IoC的实现账户的CRUD配置文件

<?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">
    <!--注册AccountService-->
    <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>
    <!--注册accountDao-->
    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
        <property name="queryRunner" ref="queryRunner"/>
    </bean>
    <!--注册queryRunner-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
        <constructor-arg name="ds" ref="dataSource"/>
    </bean>
    <!--注册数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="url" value="jdbc:mysql://localhost:3306/spring_day02?characterEncoding=utf8"/>
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>
</beans>

测试案例

public class DbTest {
    @Test
    public void fun01() throws Exception {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        AccountService accountService = (AccountService) applicationContext.getBean("accountService");
        List<Account> list = accountService.findAll();
        System.out.println(list);
    }
}

@NonNull 注解和@Nullable 注解的使用
用 @Nullable 和 @NotNull 注解来显示表明可为空的参数和以及返回值。这样就够在编译的时候处理空值而不是在运行时抛出 NullPointerExceptions。

第四章-Spring的IOC注解开发

添加依赖

<dependencies>
    <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.0.2.RELEASE</version>
    </dependency>
 </dependencies>

引入context的命名空间
applicationContext.xml中需要引入context的命名空间,可在xsd-configuration.html中找到

<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" 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">
</beans>

配置扫描
在bean标签内部，使用context:component-scan ，让spring扫描该基础包下的所有子包注解

<context:component-scan base-package="com.itheima"></context:component-scan>

在类上面添加@Component(“id”)
在applicationContext.xml 开启包扫描

用于创建对象的
相当于：
@Component
作用：
把资源让 spring 来管理。相当于在 xml 中配置一个 bean。
属性：
value：指定 bean 的 id。如果不指定id属性，默认 bean 的 id 是当前类的类名。首字母小写。

web里面的三层结构中的所有类，在spring里面都称之为 Component （组件），但是它也提供了更详细的注解来针对不同的层级声明。
三个衍生注解如下:
@Controller :修饰WEB层类 —>action | SpringMVC
@Service :修饰业务层类 —>service
@Repository :修饰DAO层类 —>dao

用于改变作用范围的@scope
@scope
singleton: 单例(默认)
prototype:多例
@Scope注解用来描述类的作用范围的，默认值singleton。如同xml中bean标签的属性scope .如果配置成多例的使用prototype。

@Scope("prototype")
@Component("accountService")
public class AccountServiceImpl implements AccountService {}

和生命周期相关的【了解】
初始化和销毁回调方法对应的注解
@PostConstrut:如同xml中bean标签的属性init-method ,用来设置spring框架初始化此类实例时调用的初始化方法,标注在此类的初始化方法上
@PreDestroy:如同xml中bean标签的属性init-method ,用来设置spring框架销毁此类实例时调用的销毁方法,标注在此类的销毁方法上
注意:这两个注解都是配在方法上的

总结：

注册Bean的相当于配置了
@Component(“id”)
@Controller(“id”) 配置web层
@Service(“id”) 配置Service层
@Repository(“id”) 配置持久层如果id不配, 默认就是类的名字,首字母小写

配置bean的作用范围
@Scope(“类型”)
singleton 单例【默认】
prototype 多例

配置和生命周期相关的
@PostConstruct init-method=""
@PreDestroy destroy-method=""

使用注解注入属性
@Value

作用：
注入基本数据类型和 String 类型数据的
属性：
value：用于指定值 , 可以通过表达式动态获得内容再赋值
实例:

@Value("奥巴马")
private String name;

@Autowired

作用：
自动按照类型注入。当使用注解注入属性时， set 方法可以省略。它只能注入其他 bean 类型。
如果只有一个实现类, 可以自动注入成功
如果有两个或者两个以上的实现类, 找到变量名一致的id对象给注入进去, 如果找不到,就报错
实例:

@Component("accountService")
public class AccountServiceImpl implements AccountService {
    @Autowired
    //当有多个AccountDao实现类时候, @Autowired会在在Spring容器里面找id为accountDao的对象注入,找不到就报错
    private AccountDao accountDao;
    @Override
    public void save() {
        System.out.println("AccountServiceImpl---save()");
        accountDao.save();
    }
}

@Qualifier

作用
在自动按照类型注入(@Autowired)的基础之上，再按照Bean的id注入。
它在给字段注入时不能独立使用，必须和@Autowire一起使用；
但是给方法参数注入时，可以独立使用。
属性
value：指定bean的id。
实例

@Component("accountService")
public class AccountServiceImpl implements AccountService {
    @Autowired
    @Qualifier(value = "accountDao02")
    private AccountDao accountDao;
    @Override
    public void save() {
        System.out.println("AccountServiceImpl---save()");
        accountDao.save();
    }
}

@Resource
如果上面一个接口有多种实现，那么现在需要指定找具体的某一个实现，那么可以使用

@Component("accountService")
public class AccountServiceImpl implements AccountService {
    @Resource(name = "accountDao02")
    private AccountDao accountDao;
    @Override
    public void save() {
        System.out.println("AccountServiceImpl---save()");
        accountDao.save();
    }
}

小结：

注入简单类型 @Value(“值/表达式”)
注入对象类型
- 如果只有一个实现类, 建议使用@Autowired
- 如果有多个实现类, 建议使用@Resource("name=“id”)

混合开发
注解和XML比较
在这里插入图片描述

xml
- 优点: 方便维护, 改xml文件
- 缺点: 相对注解而言, 麻烦一点
注解
- 优点: 开发简洁方便
- 缺点: 维护没有xml那么方便, 需要改源码

混合开发特点
使用xml(注册bean)来管理bean
使用注解来注入属性

混合开发环境搭建
创建spring配置文件，编写头信息配置

<?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"
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
     ">
</beans>

配置扫描

<context:component-scan base-package="com.itheima" />

在xml配置中添加Bean的管理
在被管理bean对应的类中，为依赖添加注解配置

小结：

xml注册(管理bean)
注解注入(给对象里面字段/属性赋值)

纯注解测试实现
@Configuration

作用：
用于指定当前类是一个spring配置类，当创建容器时会从该类上加载注解。
获取容器时需要使用AnnotationApplicationContext(类.class)。
属性：
value:用于指定配置类的字节码
示例代码:

@Configuration
public class SpringConfiguration {

}

@ComponentScan

作用：
用于指定spring在初始化容器时要扫描的包。作用和在spring的xml配置文件中的： <context:component-scan base-package=“com.itheima”/>是一样的。
属性：
basePackages：用于指定要扫描的包。和该注解中的value属性作用一样。
示例代码:

@Configuration
@ComponentScan("com.itheima")
public class SpringConfiguration {

}

@Bean

作用：
该注解只能写在方法上，表明使用此方法创建一个对象，并且放入spring容器。
属性：
name：给当前@Bean注解方法创建的对象指定一个名称(即bean的id）。
示例代码:

/**
 * 该类是一个配置类，它的作用和bean.xml是一样的
 */
@Configuration
@ComponentScan("com.itheima")
public class SpringConfiguration {

    private String driver = "com.mysql.jdbc.Driver";
    private String url = "jdbc:mysql:///spring_day02";
    private String username = "root";
    private String password = "123456";
    /**
     * 用于创建一个QueryRunner对象
     * @param dataSource
     * @return
     */
    @Bean("runner")
    public QueryRunner createQueryRunner(@Qualifier(value ="dataSource") DataSource dataSource){
        return new QueryRunner(dataSource);
    }
    /**
     * 用于创建DataSource
     * @return
     * @throws PropertyVetoException
     */
    @Bean(name = "dataSource")
    public DataSource createDataSource() throws PropertyVetoException {
        ComboPooledDataSource ds = new ComboPooledDataSource();
        ds.setDriverClass(driver);
        ds.setJdbcUrl(url);
        ds.setUser(username);
        ds.setPassword(password);
        return ds;
    }

}

@Import

作用：
用于导入其他配置类，在引入其他配置类时，可以不用再写@Configuration注解。当然，写上也没问题。
属性：
value[]：用于指定其他配置类的字节码。
示例代码:

/**
 * 该类是一个配置类，它的作用和bean.xml是一样的
 */
@Configuration
@ComponentScan("com.itheima")
@Import({JdbcConfig.class})
public class SpringConfiguration {


}

public class JdbcConfig {
    private String driver = "com.mysql.jdbc.Driver";
    private String url = "jdbc:mysql:///spring_day02";
    private String username = "root";
    private String password = "123456";
    /**
     * 用于创建一个QueryRunner对象
     * @param dataSource
     * @return
     */
    @Bean("runner")
    @Scope("prototype")
    public QueryRunner createQueryRunner(@Qualifier(value ="dataSource") DataSource dataSource){
        return new QueryRunner(dataSource);
    }
    /**
     * 用于创建DataSource
     * @return
     * @throws PropertyVetoException
     */
    @Bean(name = "dataSource")
    public DataSource createDataSource() throws PropertyVetoException {
        ComboPooledDataSource ds = new ComboPooledDataSource();
        ds.setDriverClass(driver);
        ds.setJdbcUrl(url);
        ds.setUser(username);
        ds.setPassword(password);
        return ds;
    }


}

@PropertySource

作用：
用于加载.properties文件中的配置。例如我们配置数据源时，可以把连接数据库的信息写到properties配置文件中，就可以使用此注解指定properties配置文件的位置。
属性：
value[]：用于指定properties文件位置。如果是在类路径下，需要写上classpath:
示例代码:

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_day02
jdbc.username=root
jdbc.password=123456

JdbcConfig.java
@PropertySource(value = {“classpath:jdbc.properties”})
public class JdbcConfig {
@Value(" ${jdbc.url}") private String url; @Value("$ {jdbc.driver}")
private String driver;
@Value(" ${jdbc.username}") private String username; @Value("$ {jdbc.password}")
private String password;
@Bean(“queryRunner”)
public QueryRunner createQueryRunner(DataSource dataSource){
QueryRunner queryRunner = new QueryRunner(dataSource);
return queryRunner;
}
@Bean(“dataSource”)
public DataSource createDataSource(){
DruidDataSource dataSource = new DruidDataSource();
dataSource.setUrl(url);
dataSource.setDriverClassName(driver);
dataSource.setUsername(username);
dataSource.setPassword(password);
return dataSource;
}
}
通过注解获取容器

ApplicationContext ac = new AnnotationConfigApplicationContext(SpringConfiguration.class);

小结：
在这里插入图片描述

第五章-Spring整合测试

在测试类中，每个测试方法都有以下两行代码：
ApplicationContext ac = new ClassPathXmlApplicationContext(“bean.xml”);
AccountService as= ac.getBean(“accountService”,AccountService.class);
这两行代码的作用是获取容器，如果不写的话，直接会提示空指针异常。所以又不能轻易删掉。

导入spring整合Junit的坐标

<dependency>
  		<groupId>org.springframework</groupId>
  		<artifactId>spring-test</artifactId>
  		<version>5.0.2.RELEASE</version>
  	</dependency>

在测试类上面标记注解

@RunWith(SpringJUnit4ClassRunner.class)//指明运行的测试环境
//@ContextConfiguration("classpath:applicationContext.xml")//指明spring框架的加载的配置文件【有applicationContext.xml解使用这种】
@ContextConfiguration(classes = SpringConfiguration.class)//指明spring框架的加载的配置类【纯注解使用这种】
public class DbTest
{
    @Autowired
    private AccountService accountService;

    @Test
    public void testSaveAccount() throws Exception {
        Account account = new Account();
        account.setName("王二麻子");
        account.setMoney(100f);
        accountService.save(account);
    }

}

思考问题为什么不把测试类配到xml中

在解释这个问题之前，先解除大家的疑虑，配到XML中能不能用呢？
答案是肯定的，没问题，可以使用。
那么为什么不采用配置到xml中的方式呢？
这个原因是这样的：
第一：当我们在xml中配置了一个bean，spring加载配置文件创建容器时，就会创建对象。
第二：测试类只是我们在测试功能时使用，而在项目中它并不参与程序逻辑，也不会解决需求上的问题，所以创建完了，并没有使用。那么存在容器中就会造成资源的浪费。
所以，基于以上两点，我们不应该把测试配置到xml文件中。

第六章-AOP相关的概念

什么是AOP
AOP：全称是AspectOriented Programming, 即面向切面编程。在不修改源码的基础上，对我们的已有方法进行增强。
说白了就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，进行增强
AOP实现原理
使用动态代理技术

JDK动态代理: 必须需要接口的
Cglib动态代理: 不需要接口的,只需要类就好了
小结：

AOP: 面向切面编程
作用: 不需要改变源代码对目标方法进行增强
底层实现: 动态代理

在AOP 这种思想还没有出现的时候，我们解决切面的问题思路无非有以下两种：

方式一:通过静态方法实现(缺点:需要修改源码,后期不好维护)
把需要添加的代码抽取到一个地方，然后在需要添加那些方法中引用
方式二:通过继承方案来解决(缺点:需要修改源码,继承关系复杂,后期不好维护)
抽取共性代码到父类，子类在需要的位置，调用父类方法。
上述两种方式的缺点
都会打破原来代码的平静（也就是必须要修改代码，或者就是必须事先固定好。）如果我们想在原有代码基础上扩展。并且不改动原来的代码, 就可以使用AOP了。
其实AOP 字面直译过来是面向切面编程，其实通俗一点它就是对我们的具体某个方法进行了增强而已。在之前我们对某个方法进行增强无非是两种手段，一种是装饰者模式、一种是代理模式（静态代理 & 动态代理）。 AOP 的底层使用的是动态代理方式。

AOP 的底层动态代理实现有两种方案。
一种是使用JDK的动态代理。这种是早前我们在前面的基础增强说过的。这一种主要是针对有接口实现的情况。它的底层是创建接口的实现代理类，实现扩展功能。也就是我们要增强的这个类，实现了某个接口，那么我就可以使用这种方式了. 而另一种方式是使用了cglib 的动态代理，这种主要是针对没有接口的方式，那么它的底层是创建被目标类的子类，实现扩展功能.

小结：

AOP的底层就是封装了动态代理
- JDK的动态代理
- CgLib的动态代理
JDK的动态代理: 依赖接口的, 必须有接口
CgLib的动态代理: 依赖类的(父类), 不需要接口的

学习spring中的AOP要明确的事

开发阶段（我们做的）
编写核心业务代码（开发主线）：大部分程序员来做，要求熟悉业务需求。
把公用代码抽取出来，制作成通知。（开发阶段最后再做）：AOP编程人员来做。
在配置文件中，声明切入点与通知间的关系，即切面：AOP编程人员来做。
运行阶段（Spring框架完成的）
Spring框架监控切入点方法的执行。一旦监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置，将通知对应的功能织入，完成完整的代码逻辑运行。
在spring中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。

AOP中的术语

JoinPoint: 连接点
类里面哪些方法可以被增强，这些方法称为连接点. 在spring的AOP中，指的是所有现有的方法。
Pointcut: 切入点
在类里面可以有很多方法被增强，但是实际开发中，我们只对具体的某几个方法而已，那么这些实际增强的方法就称之为切入点
Advice: 通知/增强
增强的逻辑、称为增强，比如给某个切入点(方法) 扩展了校验权限的功能，那么这个校验权限即可称之为增强或者是通知
通知分为:
前置通知：在原来方法之前执行.
后置通知：在原来方法之后执行. 特点: 可以得到被增强方法的返回值
环绕通知：在方法之前和方法之后执行. 特点:可以阻止目标方法执行
异常通知：目标方法出现异常执行. 如果方法没有异常,不会执行. 特点:可以获得异常的信息
最终通知：指的是无论是否有异常，总是被执行的。

Aspect: 切面
切入点和通知的结合
在这里插入图片描述

第七章-Spring中的AOP

前置通知
导入坐标

<dependencies>
    <!--Spring核心容器-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.0.2.RELEASE</version>
    </dependency>
    <!--SpringAOP相关的坐标-->
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.8.7</version>
    </dependency>
    
    <!--Spring整合单元测试-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-test</artifactId>
      <version>5.0.2.RELEASE</version>
    </dependency>
    <!--单元测试-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

定义被增强的业务逻辑类和切面类(增强的)

//被增强的类
public class AccountDaoImpl implements AccountDao {

    @Override
    public void save() {
        System.out.println("save()...");
    }
}

//增强的类(切面类)
public class MyAscept {
    public void checkPrivilege() {// 通知
        System.out.println("权限的校验...");
    }
}

xml中声明增强的bean （扩展的bean）和被增强的bean (被扩展的bean)

<!--注册accountDao-->
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"/>
<!--注册增强(切面)类-->
<bean id="myAscept" class="com.itheima.aspect.MyAscept"/>

定义aop的配置

 <!--配置切入点(哪个包下的哪个类哪个方法需要增强)
       expression="execution(* com.xyz.myapp.service.*.*(..))"
       第一个* 表示返回值 ，不管任何返回值。 匹配任意返回值
       com.xyz.myapp.service : 表示这个包下
       第二个* 表示这个包下的所有类
       第三个* 表示这个包下的所有类中的所有方法
       (..) : 这个表示方法的参数 .. 任意参数
       spring 根据这一套规则，能够找到具体哪一个方法来做增强了。
    -->
        -->
     <!--配置AOP-->
    <aop:config>
        <aop:pointcut id="pointCut01" expression="execution(* com.itheima.dao.impl.AccountDaoImpl.save(..))"/>
        <!--配置切面(切入点和通知的结合)-->
        <aop:aspect ref="myAscept">
            <!--前置通知-->
            <aop:before method="checkPrivilege" pointcut-ref="pointCut01"></aop:before>
        </aop:aspect>
    </aop:config>      
</aop:config>

后置通知
在原来方法之后执行. 特点: 可以得到被增强方法的返回值 <aop:after-returning …/>

<!--后置通知  -->
<aop:after-returning method="showLog" pointcut-ref="pointCut2" returning="obj"/>

环绕通知
在方法之前和方法之后执行. 特点:可以阻止目标方法执行 <aop:around …/>

//环绕通知(ProceedingJoinPoint 代表目标方法)
    public void showTime(ProceedingJoinPoint joinPoint) throws Throwable {
        //打印系统时间
        System.out.println("调用之前的时间="+System.currentTimeMillis());
        //执行目标方法
        joinPoint.proceed();
        //打印系统时间
        System.out.println("调用之后的时间="+System.currentTimeMillis());

    }

//配置
<!--环绕通知  -->
<aop:around method="showTime" pointcut-ref="pointCut3"/>

异常通知【了解】
方法出现异常执行. 如果方法没有异常,不会执行. 特点:可以获得异常的信息 <aop:after-throwing …/>

增强的方法:
public void afterThrowing(Throwable e){
	System.out.println("异常抛出通知========"+e.getMessage());
}

配置文件:
<aop:after-throwing method="afterThrowing" throwing="e" pointcut-ref="pointCut4"/>

最终通知【了解】
指的是无论是否有异常，总是被执行的。 <aop:after …/>

<!--最终通知  -->
<aop:after method="after" pointcut-ref="pointCut4"/>

定义切面类,在切面增强类上面使用注解 @Aspect并且在切面类中定义切入点方法

@Aspect
public class MyAscept {
    @Before(value = "execution(* com.itheima.dao.impl.AccountDaoImpl.save(..))")
    public void checkPrivilege() {// 通知
        System.out.println("权限的校验...");
    }
}

创建配置文件

<?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">

    <!--注册accountDao-->
    <bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl"/>
    <!--注册切面类-->
    <bean id="myAscept" class="com.itheima.aspect.MyAscept"/>
    <!--开启AOP注解-->
    <aop:aspectj-autoproxy/>
</beans>

后置通知

@AfterReturning(value = "execution(* com.itheima.dao.impl.AccountDaoImpl.delete(..))",returning="obj")
public void showLog(Object obj) {
        System.out.println("显示删除之后的日志..." + obj);
}

环绕通知

// 打印时间(环绕通知)
    @Around(value = "execution(* com.itheima.dao.impl.AccountDaoImpl.findAll(..))")
    public void showTime(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("执行之前的时间:" + System.currentTimeMillis());
        //执行findAll
        joinPoint.proceed();
        System.out.println("执行之后的时间:" + System.currentTimeMillis());

    }

异常通知【了解】

 //测试异常通知
    @AfterThrowing(value="execution(* com.itheima.dao.impl.AccountDaoImpl.update(..))",throwing="e")
    public void showException(Throwable e) {
        System.out.println("异常通知...." + e.getMessage());
    }

最终通知【了解】

//测试最终通知
    @After(value = "execution(* com.itheima.dao.impl.AccountDaoImpl.update(..))")
    public void showFinal() {
        System.out.println("最终通知...");
    }

第八章-Spring中的JdbcTemplate 【了解】

JdbcTemplate是Spring里面的持久层一个工具包, 封装了Jdbc
使用步骤
- 创建DataSource
- 创建JDBCTemplate
- 调用update(), query(), queryForObject()

方式一：
AccountDaoImpl.java

public class AccountDaoImpl implements AccountDao {

	private JdbcTemplate jdbcTemplate;
	
	public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
		this.jdbcTemplate = jdbcTemplate;
	}

	@Override
	public Account findAccountById(Integer id) {
		List<Account> list =  jdbcTemplate.query("select * from account where id = ? ",new AccountRowMapper(),id);
		return list.isEmpty()?null:list.get(0);
	}

	@Override
	public Account findAccountByName(String name) {
		List<Account> list =  jdbcTemplate.query("select * from account where name = ? ",new AccountRowMapper(),name);
		if(list.isEmpty()){
			return null;
		}
		if(list.size()>1){
			throw new RuntimeException("结果集不唯一，不是只有一个账户对象");
		}
		return list.get(0);
	}

	@Override
	public void updateAccount(Account account) {
		jdbcTemplate.update("update account set money = ? where id = ? ",account.getMoney(),account.getId());
	}

}

applicationContext.xml

<!-- 配置一个dao -->
	<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
		<!-- 注入jdbcTemplate -->
		<property name="jdbcTemplate" ref="jdbcTemplate"></property>
	</bean>
	
	<!-- 配置一个数据库的操作模板：JdbcTemplate -->
	<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
	<!-- 配置数据源 -->
	<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
		<property name="url" value="jdbc:mysql:///spring_day04"></property>
		<property name="username" value="root"></property>
		<property name="password" value="123456"></property>
	</bean>

方式二：
AccountDaoImpl.java

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {

	@Override
	public Account findAccountById(Integer id) {
		//getJdbcTemplate()方法是从父类上继承下来的。
		List<Account> list = getJdbcTemplate().query("select * from account where id = ? ",new AccountRowMapper(),id);
		return list.isEmpty()?null:list.get(0);
	}

	@Override
	public Account findAccountByName(String name) {
		//getJdbcTemplate()方法是从父类上继承下来的。
		List<Account> list =  getJdbcTemplate().query("select * from account where name = ? ",new AccountRowMapper(),name);
		if(list.isEmpty()){
			return null;
		}
		if(list.size()>1){
			throw new RuntimeException("结果集不唯一，不是只有一个账户对象");
		}
		return list.get(0);
	}

	@Override
	public void updateAccount(Account account) {
		//getJdbcTemplate()方法是从父类上继承下来的。
		getJdbcTemplate().update("update account set money = ? where id = ? ",account.getMoney(),account.getId());
	}
}

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"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans 
    	http://www.springframework.org/schema/beans/spring-beans.xsd">
	
<!-- 配置dao2 -->
<bean id="accountDao" class="com.itheima.dao.impl.AccountDaoImpl">
	<!-- 注入dataSource -->
	<property name="dataSource" ref="dataSource"></property>
</bean>
<!-- 配置数据源 -->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
	<property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
	<property name="url" value="jdbc:mysql:///spring_day04"></property>
		<property name="username" value="root"></property>
		<property name="password" value="123456"></property>
	</bean>
</beans>

第九章-Spring管理事务

概述：
由于Spring对持久层的很多框架都有支持， Hibernate 、 jdbc 、JdbcTemplate , MyBatis 由于使用的框架不同，所以使用事务管理操作API 也不尽相同。为了规范这些操作， Spring统一定义一个事务的规范，这其实是一个接口。这个接口的名称： PlatformTrasactionManager.并且它对已经做好的框架都有支持.
如果dao层使用的是JDBC, JdbcTemplate 或者mybatis,那么可以使用DataSourceTransactionManager 来处理事务
如果dao层使用的是 Hibernate, 那么可以使用HibernateTransactionManager 来处理事务

相关的API
PlatformTransactionManager
平台事务管理器是一个接口，实现类就是Spring真正管理事务的对象。
常用的实现类:
DataSourceTransactionManager :JDBC开发的时候(JDBCTemplate,MyBatis)，使用事务管理。
HibernateTransactionManager :Hibernate开发的时候，使用事务管理。
TransactionDefinition
事务定义信息中定义了事务的隔离级别，传播行为，超时信息，只读。TransactionStatus:事务的状态信息
事务状态信息中定义事务是否是新事务，是否有保存点。

编程式(硬编码)事务【了解】

public class JDBCTempleTest {
	 @Test
	 public void fun01() throws PropertyVetoException{
			//1. 创建数据源
			 ComboPooledDataSource dataSource = new ComboPooledDataSource();
			 dataSource.setDriverClass("com.mysql.jdbc.Driver");
			 dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/spring_day03");
			 dataSource.setUser("root");
			 dataSource.setPassword("123456");
			 //2. 创建jdbc模版
			 final JdbcTemplate jdbcTemplate = new JdbcTemplate();
			 jdbcTemplate.setDataSource(dataSource);
			 //3.创建事务管理器
			 DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
			 transactionManager.setDataSource(dataSource);
			 //4.创建事务模版
			 TransactionTemplate transactionTemplate = new TransactionTemplate();
			 transactionTemplate.setTransactionManager(transactionManager);
			 	//4. 进行事务操作
			 transactionTemplate.execute(new TransactionCallback<Object>() {
                @Override
                public Object doInTransaction(TransactionStatus status) {
                    //操作数据库
                    jdbcTemplate.update("update t_account set money = money - ? where name = ?  ", 	100.0,"zs");

                    int i = 1/0;

                    jdbcTemplate.update("update t_account set money = money + ? where name = ?  ", 100.0,"ls");
                    return null;
                }
            });
         }
}

我们项目开发一般不会使用编程式(硬编码)方式. 一般使用声明式(配置)事务

xml方式
注解方式

Spring声明式事务-xml配置方式【重点】
配置事务管理器

<bean id="transactionManager" 		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
</bean>

配置事务建议(事务的规则)

<tx:advice id="adviceId" transaction-manager="transactionManager">
  <!--在tx:advice标签内部 配置事务的属性 -->
  <tx:attributes>
  <!-- 指定方法名称：是业务核心方法 
      read-only：是否是只读事务。默认false，不只读。
      isolation：指定事务的隔离级别。默认值是使用数据库的默认隔离级别。 
      propagation：指定事务的传播行为。
      timeout：指定超时时间。默认值为：-1。永不超时。
      rollback-for：用于指定一个异常，当执行产生该异常时，事务回滚。产生其他异常，事务不回滚。没有默认值，任何异常都回滚。
      no-rollback-for：用于指定一个异常，当产生该异常时，事务不回滚，产生其他异常时，事务回滚。没有默认值，任何异常都回滚。
      -->
      <tx:method name="*" read-only="false" propagation="REQUIRED"/>
      <tx:method name="find*" read-only="true" propagation="SUPPORTS"/>
  </tx:attributes>
</tx:advice>

配置事务的AOP

<aop:config>
	<!-- 定义切入点 ，也就是到底给那些类中的那些方法加入事务的管理 -->
	<aop:pointcut expression="execution(* com.itheima.service.impl.*.*(..))" id="pointCat"/>
	<!-- 让切入点和事务的建议绑定到一起 -->
	<aop:advisor advice-ref="txAdvice" pointcut-ref="pointCat"/>
</aop:config>

spring声明式事务-注解方式【重点】
在applicationContext里面打开注解驱动

<!--一,配置事务管理器  -->
	<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	
<!--二配置事务注解  -->
<tx:annotation-driven transaction-manager="transactionManager"/>

在业务逻辑类上面使用注解
@Transactional ：如果在类上声明，那么标记着该类中的所有方法都使用事务管理。也可以作用于方法上，那么这就表示只有具体的方法才会使用事务。

xml方式
- 优点: 只需要配一次, 全局生效, 容易维护
- 缺点: 相对注解而言要麻烦一点
注解方式
- 优点: 配置简单
- 缺点: 写一个业务类就配置一次, 事务细节不好处理, 不好维护

集合，到我这里来

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring(IOC,DI,AOP)详解

第一章-Spring概述Spring介绍概述：Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。简单来说，Spring是一个分层的JavaSE/EE full-stack(一站式) 轻量级开源框架。一站式:Spring提供了三层解决方案.Spring ...
复制链接

扫一扫