Spring学习笔记

Spring

此笔记相关学习视频：黑马程序员SSM

什么是Spring

就一很牛的轻量级开源框架:D

提供了展现层 SpringMVC 和持久层 Spring JDBCTemplate 以及业务层事务管理等众多的企业级应用技术
，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE 企业应用开源框架。

本来是这样的

---

用了Spring后变成了这样

---

Spring程序开发步骤

① 导入 Spring 开发的基本包坐标
② 编写 Dao 接口和实现类
③ 创建 Spring 核心配置文件 pplicationContext.xml
④ 在 Spring 配置文件中配置 UserDaoImpl
⑤ 使用 Spring 的 API 获得 Bean 实例
创建ApplicationContext对象getBean

---

导坐标

pom.xml
<properties>
    <spring.version>5.0.5.RELEASE</spring.version>
</properties>
<dependencies>
    <!--导入spring的context坐标，context依赖core、beans、expression-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
</dependencies>

---

编写Dao接口和实现类

public interface UserDao {
    public void save();
}
public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("UserDao save method running....");
    }
}

---

创建Spring核心配置文件and配置UserDaoImpl

在类路径下（resources）创建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">

    <bean id="userDao" class="dao.impl.UserDaoImpl"></bean>
    <!--id：Bean实例在Spring容器中的唯一标识
        class：Bean的全限定名称-->
    <!--用于配置对象交由 Spring 来创建。默认情况下它调用的是类中的 无参构造函数 ，
    如果没有无参构造函数则不能创建成功。-->
</beans>

使用Spring的API获得Bean实例

public void test(){
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    UserDao userDao = (UserDao) applicationContext.getBean("userDao");
    userDao.save();
}

---

Spring配置文件详解

<bean>标签
    id属性:在容器中Bean实例的唯一标识，不允许重复
    class属性:要实例化的Bean的全限定名
    scope属性:Bean的作用范围，常用是Singleton(默认)和prototype
        <property>标签：属性注入
        name属性：属性名称
        value属性：注入的普通属性值
        ref属性：注入的对象引用值
        <list>标签
        <map>标签
        <properties>标签
    <constructor-arg>标签
<import>标签:导入其他的Spring的分文件

---

Bean标签

基本配置

作用：用于配置对象交由Spring 来创建。
默认情况下它调用的是类中的无参构造函数，如果没有无参构造函数则不能创建成功。
基本属性：id，class

Bean标签范围配置

scope：指对象的作用范围，取值如下：

取值范围	说明
singleton	默认值，单例的
prototype	多例的
request WEB	项目中，Spring 创建一个 Bean 的对象，将对象存入到 request 域中
session WEB	项目中，Spring 创建一个 Bean 的对象，将对象存入到 session 域中
global session	WEB 项目中，应用在 Portlet 环境，如果没有 Portlet 环境那么globalSession 相当于 session

1）当scope的取值为singleton时

• Bean的实例化个数：1个
• Bean的实例化时机：当Spring核心文件被加载时，实例化配置的Bean实例
• Bean的生命周期：
  • 对象创建：当应用加载，创建容器时，对象就被创建了
  • 对象运行：只要容器在，对象一直活着
  • 对象销毁：当应用卸载，销毁容器时，对象就被销毁了

2）当scope的取值为prototype时

• Bean的实例化个数：多个
• Bean的实例化时机：当调用getBean()方法时实例化Bean
  • 对象创建：当使用对象时，创建新的对象实例
  • 对象运行：只要对象在使用中，就一直活着
  • 对象销毁：当对象长时间不用时，被 Java 的垃圾回收器回收了

---

Bean实例化三种方式

1） 使用无参构造方法实例化
它会根据默认无参构造方法来创建类对象，如果bean中没有默认无参构造函数，将会创建失败

<bean id="userDao" class="dao.impl.UserDaoImpl"/>

2） 工厂静态方法实例化

<bean id="userDao" class="factory.StaticFactoryBean" 
    factory-method="createUserDao" />

public class StaticFactoryBean {
    public static UserDao createUserDao(){
        return new UserDaoImpl();
    }
}

3） 工厂实例方法实例化
工厂的非静态方法返回Bean实例

<bean id="factoryBean" class="factory.DynamicFactoryBean"/>
<bean id="userDao" factory-bean="factoryBean" factory-method="createUserDao"/>

public class DynamicFactoryBean {
    public UserDao createUserDao(){
        return new UserDaoImpl();
    }
}

---

Bean的依赖注入( DI )

概念：
DI 依赖注入（Dependency Injection）————是 Spring 框架核心 IOC 的具体实现。
在编写程序时，通过控制反转，把对象的创建交给了 Spring，但是代码中不可能出现没有依赖的情况。

AOP通过DI来实现功能

IOC 解耦只是降低他们的依赖关系，但不会消除。例如：业务层仍会调用持久层的方法。
那这种业务层和持久层的依赖关系，在使用 Spring 之后，就让 Spring 来维护了。
简单的说，就是坐等框架把持久层对象传入业务层，而不用我们自己去获取。

引例：
① 创建 UserService，UserService 内部再调用 UserDao的save() 方法

public class UserServiceImpl implements UserService {
    @Override
    public void save() {
        ApplicationContext applicationContext = new 
        ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");//
        userDao.save();
    }
}

② 将 UserServiceImpl 的创建权交给 Spring

<bean id="userService" class="service.impl.UserServiceImpl"/>

③ 从 Spring 容器中获得 UserService 进行操作

ApplicationContext applicationContext = new 
ClassPathXmlApplicationContext("applicationContext.xml");
UserService userService = (UserService) applicationContext.getBean("userService");//
userService.save();

那么这么做会有什么后果捏:p

---

所以我们不妨这么做：

---

那么怎么样将UserDao怎样注入到UserService内部呢？

way1：通过-构造方法-

构造方法注入

//创建有参构造
public class UserServiceImpl implements UserService {
    @Override
    public void save() {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userDao = (UserDao) applicationContext.getBean("userDao");
        userDao.save();
    }
}

<!--配置Spring容器调用有参构造时进行注入-->
<bean id="userDao" class="dao.impl.UserDaoImpl"/>
<bean id="userService" class="service.impl.UserServiceImpl">
    <constructor-arg name="userDao" ref="userDao"></constructor-arg>
</bean>

---

way2：通过-set方法-

set方法注入

也就是在UserServiceImpl中添加setUserDao方法

public class UserServiceImpl implements UserService {
    
    private UserDao userDao;//看这里

    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }
    @Override
    public void save() {
        userDao.save();
    }
}

配置Spring容器调用set方法进行注入

<bean id="userDao" class="dao.impl.UserDaoImpl"/>

<bean id="userService" class="service.impl.UserServiceImpl">
    <property name="userDao" ref="userDao"/>
    <!--这个ref对应上面的id-->
</bean>

<!--或者使用p命名空间进行注入【本质相同】-->
xmlns:p="http://www.springframework.org/schema/p"<!--引入P命名空间-->
<!--修改注入方式-->
<bean id="userService" class="service.impl.UserServiceImpl" p:userDao-ref="userDao"/>

---

依赖注入的数据类型

注入数据的三种数据类型

• 普通数据类型

public class UserDaoImpl implements UserDao {
    private String name;
    private int age;
    //有相应的set方法
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void save() {
        System.out.println("UserDao save method running....");
    }
}

<bean id="userDao" class="dao.impl.UserDaoImpl">
    <property name="name" value="judy"></property>
    <property name="age" value="19"></property>
</bean>

• 引用数据类型
  引例就是引用数据类型注入，这里不再赘述
• 集合数据类型
  集合数据类型（List）的注入

public class UserDaoImpl implements UserDao {
    private List<String> strList;
        public void setStrList(List<String> strList) {
        this.strList = strList;
    }

    private List<User> userList;
    public void setUserList(List<User> userList) {
        this.userList = userList;
    }

    private Map<String,User> userMap;
    public void setUserMap(Map<String, User> userMap) {
        this.userMap = userMap;
    }

    private Properties properties;
    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    public void save() {
        System.out.println("UserDao save method running....");
    }
}

<!--集合数据类型（List<String>）的注入-->
<bean id="userDao" class="dao.impl.UserDaoImpl">
    <property name="strList">
        <list>
            <value>aaa</value>
            <value>bbb</value>
            <value>ccc</value>
        </list>
    </property>
</bean>
<!--集合数据类型（List<User>）的注入-->
<bean id="u1" class="domain.User"/>
<bean id="u2" class="domain.User"/>
<bean id="userDao" class="dao.impl.UserDaoImpl">
    <property name="userList">
        <list>
            <bean class="domain.User"/>
            <bean class="domain.User"/>
            <ref bean="u1"/>
            <ref bean="u2"/>
        </list>
    </property>
</bean>
<!--集合数据类型（ Map<String,User> ）的注入-->
<bean id="u1" class="domain.User"/>
<bean id="u2" class="domain.User"/>
<bean id="userDao" class="dao.impl.UserDaoImpl">
    <property name="userMap">
        <map>
            <entry key="user1" value-ref="u1"/>
            <entry key="user2" value-ref="u2"/>
        </map>
    </property>
</bean>
<!--集合数据类型（Properties）的注入-->
<bean id="userDao" class="dao.impl.UserDaoImpl">
    <property name="properties">
        <props>
            <prop key="p1">aaa</prop>
            <prop key="p2">bbb</prop>
            <prop key="p3">ccc</prop>
        </props>
    </property>
</bean>

---

引入其他配置文件（分模块开发）

<!--可以将部分配置拆解到其他配置文件中,
在Spring主配置文件通过import标签进行加载-->
<import resource="applicationContext-xxx.xml"/>

---

Spring相关API

/*【模板】*/ApplicationContext app = new ClasspathXmlApplicationContext("xml文件")
/*
1）ClassPathXmlApplicationContext
    它是从类的根路径下加载配置文件 推荐使用这种
2）FileSystemXmlApplicationContext
    它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。
3）AnnotationConfigApplicationContext
    当使用注解配置容器对象时，需要使用此类来创建 spring 容器。它用来读取注解。
*/
//--------------------------------------------------
//两种方式：
/*【模板】*/app.getBean("id")
/*例1*/UserService userService1 = (UserService) applicationContext.getBean("userService");

/*【模板】*/app.getBean(Class)
/*例2*/UserService userService2 = applicationContext.getBean(UserService.class);

/*
getBean()方法使用:
源码：
public Object getBean(String name) throws BeansException {
    assertBeanFactoryActive();
    return getBeanFactory().getBean(name);
}
public <T> T getBean(Class<T> requiredType) throws BeansException {
    assertBeanFactoryActive();
    return getBeanFactory().getBean(requiredType);
}
其中，当参数的数据类型是字符串时，表示根据Bean的id从容器中获得Bean实例，返回是Object，需要强转。【如例1】

当参数的数据类型是Class类型时，表示根据类型从容器中匹配Bean实例，当容器中相同类型的Bean有多个时，则此方法会报错。【如例2】

*/

---

Spring配置数据源

开发步骤:
① 导入数据源的坐标和数据库驱动坐标
② 创建数据源对象
③ 设置数据源的基本连接数据
④ 使用数据源获取连接资源和归还连接资源

导坐标

<!-- 当然也可以也别的数据库连接池 -->
<!-- C3P0连接池 -->
<dependency>
    <groupId>c3p0</groupId>
    <artifactId>c3p0</artifactId>
    <version>X.X.X</version>
</dependency>
<!-- Druid连接池 -->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>X.X.X</version>
</dependency>
<!-- mysql驱动 要注意对应自己数据库版本-->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>x.x.x</version>
</dependency>

jdbc.properties配置文件
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/dataBase
jdbc.username=root
jdbc.password=123123

mysql8.0+
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/dataBase
//?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=UTC
jdbc.username=root
jdbc.password=123123

---

DataSource有 无参构造方法，而Spring默认就是通过无参构造方法实例化对象的

DataSource要想使用 需要通过set方法设置数据库连接信息，而Spring可以通过set方法进行字符串注入
所以不妨将DataSource的创建权交由Spring容器去完成

<!--引入context命名空间和约束路径：
命名空间：xmlns:context="http://www.springframework.org/schema/context"
约束路径：http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd
-->

<!--抽取jdbc配置文件:解耦
applicationContext.xml加载jdbc.properties配置文件获得连接信息。-->
<context:property-placeholder location="classpath:jdbc.properties"/>
<!--c3p0-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
                    <!--//不同数据库连接池class不同-->
    <property name="driverClass" value="${jdbc.driver}"/>
    <property name="jdbcUrl" value="${jdbc.url}"/>
    <property name="user" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
</bean>

ApplicationContext applicationContext = new  ClassPathXmlApplicationContext("applicationContext.xml");
DataSource dataSource = (DataSource) applicationContext.getBean("dataSource");
Connection connection = dataSource.getConnection();
System.out.println(connection);//测试从容器当中获取数据源

---

Spring注解开发

（万能的注解…代替>Bean<

注解	说明
@Component	使用在类上用于实例化Bean
@Controller	使用在web层类上用于实例化Bean
@Service	使用在service层类上用于实例化Bean
@Repository	使用在dao层类上用于实例化Bean
@Autowired	使用在字段上用于根据类型依赖注入
@Qualifier	结合@Autowired一起使用用于根据名称进行依赖注入
@Resource	相当于@Autowired+@Qualifier，按照名称进行注入
@Value	注入普通属性
@Scope	标注Bean的作用范围
@PostConstruct	使用在方法上标注该方法是Bean的初始化方法
@PreDestroy	使用在方法上标注该方法是Bean的销毁方法

-注意-
使用注解进行开发时，需要在applicationContext.xml中配置组件扫描，

作用是指定哪个包及其子包下的Bean需要进行扫描以便识别使用注解配置的类、字段和方法。

<!--注解的组件扫描-->
<context:component-scan base-package="com.ABC12345678"></context:component-scan>

---

Spring原始注解

//使用 @Compont 或 @Repository标识UserDaoImpl需要Spring进行实例化。
    //@Component("userDao")
    @Repository("userDao")
    public class UserDaoImpl implements UserDao {
        @Override
        public void save() {
            System.out.println("save running... ...");
        }
    }


//使用 @Compont 或 @Service 标识UserServiceImpl需要Spring进行实例化
//使用 @Autowired 或者 @Autowired+@Qulifier 或者 @Resource进行userDao的注入
    //@Component("userService")
    @Service("userService")
    public class UserServiceImpl implements UserService {
        /*@Autowired
        @Qualifier("userDao")*/
        @Resource(name="userDao")
        private UserDao userDao;

        @Override
        public void save() {
            userDao.save();
        }
    }


//使用 @Value进行字符串的注入
//使用 @Scope标注Bean的范围
    //@Scope("prototype")
    @Scope("singleton")
    @Repository("userDao")
    public class UserDaoImpl implements UserDao {
        @Value("注入普通数据")
        private String str;

        @Value("${jdbc.driver}")
        private String driver;

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


//使用@PostConstruct标注初始化方法，使用@PreDestroy标注销毁方法
    @PostConstruct
    public void init(){
        System.out.println("初始化方法....");
    }

    @PreDestroy
    public void destroy(){
        System.out.println("销毁方法.....");
    }

---

Spring新注解

注解	说明
@Configuration	用于指定当前类是一个 Spring 配置类，当创建容器时会从该类上加载注解
@Bean	使用在方法上，标注将该方法的返回值存储到 Spring 容器中
@PropertySource	用于加载 XXX.properties 文件中的配置
@Import	用于导入其他配置类
@ComponentScan	用于指定 Spring 在初始化容器时要扫描的包。作用和在 Spring 的 xml 配置文件中的<context:component-scan base-package=“com.itheima”/>一样

@Configuration
@ComponentScan("com.ABC12345678")
@Import({DataSourceConfiguration.class})
public class SpringConfiguration {
    //略
}

@PropertySource("classpath:jdbc.properties")
public class DataSourceConfiguration {
    @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(name="dataSource")
public DataSource getDataSource() throws PropertyVetoException {
    ComboPooledDataSource dataSource = new ComboPooledDataSource();
    dataSource.setDriverClass(driver);
    dataSource.setJdbcUrl(url);
    dataSource.setUser(username);
    dataSource.setPassword(password);
    return dataSource;
}
//测试加载核心配置类创建Spring容器
@Test
public void testAnnoConfiguration() throws Exception {
    ApplicationContext applicationContext = new 
    AnnotationConfigApplicationContext(SpringConfiguration.class);
    UserService userService = (UserService) 
    applicationContext.getBean("userService");
    userService.save();
    DataSource dataSource = (DataSource) 
    applicationContext.getBean("dataSource");
    Connection connection = dataSource.getConnection();
    System.out.println(connection);
}

---

Spring集成web环境

ApplicationContext应用上下文获取方式

为什么要用这种方式？
原因很简单，因为这种方式好（废话 :p

应用上下文对象是通过new ClasspathXmlApplicationContext(spring配置文件) 方式获取的，但是每次从
容器中获得Bean时都要编写new ClasspathXmlApplicationContext(spring配置文件)，这样的弊端是配置
文件加载多次，应用上下文对象创建多次，占内存。

所以我们不妨使用ServletContextListener监听Web应用的启动，在Web应用启动时，就加载Spring的配置文件，创建应用上下文对象ApplicationContext，在将其存储到最大的域servletContext域中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了。

Spring提供了一个监听器ContextLoaderListener就是对上述功能的封装，该监听器内部加载Spring配置文件，创建应用上下文对象，并存储到ServletContext域中，提供了一个客户端工具WebApplicationContextUtils供使用者获得应用上下文对象。

具体使用方法：
① 在web.xml中配置ContextLoaderListener监听器（导入spring-web坐标）
② 使用WebApplicationContextUtils获得应用上下文对象ApplicationContext

导入Spring集成web的坐标

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>X.X.X</version>
</dependency>

配置ContextLoaderListener监听器

《web.xml》
<!--全局参数-->
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>
<!--Spring的监听器-->
<listener>
    <listener-class>
        org.springframework.web.context.ContextLoaderListener
    </listener-class>
</listener>

最后，我们便可以通过工具获得应用上下文对象了

ApplicationContext applicationContext = WebApplicationContextUtils.getWebApplicationContext(servletContext);
Object obj = applicationContext.getBean("id");

---

面向切面编程AOP

AOP（面向切面编程）

• 作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强
• 优势：减少重复代码，提高开发效率，并且便于维护
  AOP底层实现
  AOP 的底层是通过 Spring 提供的的动态代理技术实现的。在运行期间，Spring通过动态代理技术动态
  的生成代理对象，代理对象方法执行时进行增强功能的介入，在去调用目标对象的方法，从而完成功能的增强。

---

AOP 的动态代理技术

JDK 代理 : 基于接口的动态代理技术

//目标类接口
public interface TargetInterface {
    public void method();
}

//目标类
public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}

//动态代理代码
Target target = new Target(); //创建目标对象
//创建代理对象
TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),new InvocationHandler() {
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) 
        throws Throwable {
            System.out.println("前置增强代码...");
            Object invoke = method.invoke(target, args);
            System.out.println("后置增强代码...");
            return invoke;
        }
    }
);

//调用代理对象的方法测试：proxy.method();
控制台：
前置增强代码...
Target running...
后置增强代码...

---

cglib 代理：基于父类的动态代理技术

//目标类
public class Target {
    public void method() {
        System.out.println("Target running....");
    }
}

//动态代理代码
Target target = new Target(); //创建目标对象
Enhancer enhancer = new Enhancer(); //创建增强器
enhancer.setSuperclass(Target.class); //设置父类
enhancer.setCallback(new MethodInterceptor() { //设置回调
    @Override
    public Object intercept(Object o, Method method, Object[] objects, 
    MethodProxy methodProxy) throws Throwable {
        System.out.println("前置代码增强....");
        Object invoke = method.invoke(target, objects);
        System.out.println("后置代码增强....");
        return invoke;
    }
});
Target proxy = (Target) enhancer.create(); //创建代理对象

//调用代理对象的方法测试：proxy.method();
控制台：
前置增强代码...
Target running...
后置增强代码...

---

相关术语：

• Target（目标对象）：代理的目标对象
• Proxy （代理）：一个类被 AOP 织入增强后，就产生一个结果代理类
• Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法，因为spring只支持方法类型的连接点
• Pointcut（切入点）：被增强的方法所谓切入点是指我们要对哪些 Joinpoint 进行拦截的定义
• Advice（通知/ 增强）：封装增强业务逻辑的方法所谓通知是指拦截到 Joinpoint 之后所要做的事情就是通知
• Aspect（切面）：切点+通知是切入点和通知（引介）的结合
• Weaving（织入）：将切点与通知结合的过程是指把增强应用到目标对象来创建新的代理对象的过程。spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入

举例说明：
- Joinpoint（连接点）：所有菜（名词）											}	所有方法
- Pointcut（切入点）：菜的描述（形容词，红的，甜的......）						}	目标方法
- Advice（通知/ 增强）：吃（动作）												}	操作
- Aspect（切面）：吃特定的菜（动作+形容词+名词）									}	对目标方法进行操作

---

AOP开发

需要编写的内容

1. 编写核心业务代码（目标类的目标方法）
2. 编写切面类，切面类中有通知(增强功能方法)
3. 在配置文件中，配置织入关系，即将哪些通知与哪些连接点进行结合

基于 XML 的 AOP 开发

① 导入 AOP 相关坐标
② 创建目标接口和目标类（内部有切点）
③ 创建切面类（内部有增强方法）
④ 将目标类和切面类的对象创建权交给 spring
⑤ 在 applicationContext.xml 中配置织入关系
⑥ 测试代码

导坐标

<!--导入spring的context坐标，context依赖aop-->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>X.X.X</version>
</dependency>
<!-- aspectj的织入 -->
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>X.X.X</version>
</dependency>

//创建目标接口和目标类（内部有切点）
public interface TargetInterface {
    public void method();
}
//------------------------------------
public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}

//创建切面类（内部有增强方法）
public class MyAspect {
    //前置增强方法
    public void before(){
        System.out.println("前置代码增强.....");
    }
}

<!--配置目标类-->
<bean id="target" class="aop.Target"></bean>
<!--配置切面类-->
<bean id="myAspect" class="aop.MyAspect"></bean>

<!--在 applicationContext.xml 中配置织入关系-->

    <!--导入aop命名空间
    xmlns:aop="http://www.springframework.org/schema/aop"
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd-->

    <!--配置切点表达式和前置增强的织入关系-->
    <aop:config>
        <!--引用myAspect的Bean为切面对象-->
        <aop:aspect ref="myAspect">
            <!--配置Target的method方法执行时要进行myAspect的before方法前置增强-->
            <aop:before method="before" pointcut="execution(public void aop.Target.method())">
            <!--切点表达式的写法:
            execution([修饰符] 返回值类型 包名.类名.方法名(参数))
            1. 访问修饰符可以省略
            2. 返回值类型、包名、类名、方法名可以使用星号* 代表任意
            3. 包名与类名之间一个点 . 代表当前包下的类，两个点 .. 表示当前包及其子包下的类
            4. 参数列表可以使用两个点 .. 表示任意个数，任意类型的参数列表
            例子：
            execution(public void aop.Target.method())
            execution(void aop.Target.*(..))
            execution(* aop.*.*(..))
            execution(* aop..*.*(..))
            execution(* *..*.*(..))
            -->
            </aop:before>
            <!--通知的配置语法：<aop:通知类型 method=“切面类中方法名” pointcut=“切点表达式"></aop:通知类型>-->
        </aop:aspect>
    </aop:config>

<!--
    <aop:config>
        <aop:aspect ref=“切面类”>
            <aop:before method=“通知方法名称” pointcut=“切点表达式"></aop:before>
        </aop:aspect>
    </aop:config> 
-->

名称	标签	说明
前置通知	aop:before	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	aop:after-returning	用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知	aop:around	用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
异常抛出通知	aop:throwing	用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知	aop:after	用于配置最终通知。无论增强方式执行是否有异常都会执行

<!--切点表达式的抽取-->
<!--当多个增强的切点表达式相同时，可以将切点表达式进行抽取，在增强中使用 pointcut-ref 属性代替 pointcut 属性来引用抽取后的切点表达式。-->
<aop:config>
    <!--引用myAspect的Bean为切面对象-->
    <aop:aspect ref="myAspect">
        <aop:pointcut id="myPointcut" expression="execution(* com.itheima.aop.*.*(..))"/>
        <aop:before method="before" pointcut-ref="myPointcut"></aop:before>
    </aop:aspect>
</aop:config>

//测试代码
@ContextConfiguration("classpath:applicationContext.xml")
    public class AopTest {
        @Autowired
        private TargetInterface target;
        @Test
        public void test1(){
            target.method();
    }
}

---

基于注解的 AOP 开发

步骤：
① 创建目标接口和目标类（内部有切点）
② 创建切面类（内部有增强方法）
③ 将目标类和切面类的对象创建权交给 spring
④ 在切面类中使用注解配置织入关系
⑤ 在配置文件中开启组件扫描和 AOP 的自动代理
⑥ 测试

//创建目标接口和目标类（内部有切点）
public interface TargetInterface {
    public void method();
}
//------------------------------------
//将目标类和切面类的对象创建权交给 spring
@Component("target")
public class Target implements TargetInterface {
    @Override
    public void method() {
        System.out.println("Target running....");
    }
}

//创建切面类（内部有增强方法）
//在切面类中使用注解配置织入关系
@Component("myAspect")
@Aspect
public class MyAspect {
    @Before("execution(* aop.*.*(..))")
    public void before(){
        //前置增强方法
        System.out.println("前置代码增强.....");
    }
}

通知的配置语法：@通知注解(“切点表达式")

名称	注解	说明
前置通知	@Before	用于配置前置通知。指定增强的方法在切入点方法之前执行
后置通知	@AfterReturning	用于配置后置通知。指定增强的方法在切入点方法之后执行
环绕通知	@Around	用于配置环绕通知。指定增强的方法在切入点方法之前和之后都执行
异常抛出通知	@AfterThrowing	用于配置异常抛出通知。指定增强的方法在出现异常时执行
最终通知	@After	用于配置最终通知。无论增强方式执行是否有异常都会执行

<!--在配置文件中开启组件扫描和 AOP 的自动代理-->
<!--组件扫描-->
<context:component-scan base-package="aop"/>

<!--aop的自动代理-->
<aop:aspectj-autoproxy></aop:aspectj-autoproxy>

///测试代码
@ContextConfiguration("classpath:applicationContext.xml")
public class AopTest {
    @Autowired
    private TargetInterface target;
    @Test
    public void test(){
        target.method();
    }
}

---

声明式事务控制

Spring 的声明式事务顾名思义就是采用声明的方式来处理事务。这里所说的声明，就是指在配置文件中声明，用在 Spring 配置文件中声明式的处理事务来代替代码式的处理事务。Spring 声明式事务控制底层就是AOP。

作用：

• 事务管理不侵入开发的组件。具体来说，业务逻辑对象就不会意识到正在事务管理之中，事实上也应该如此，因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策划的话，也只需要在定义文件中重新配置即可
• 在不需要事务管理的时候，只要在设定文件上修改一下，即可移去事务管理服务，无需改变代码重新编译，这样维护起来极其方便

编程式事务控制相关对象

PlatformTransactionManager

PlatformTransactionManager 接口是 spring 的事务管理器，它里面提供了我们常用的操作事务的方法。

方法	说明
TransactionStatus getTransaction(TransactionDefination defination)	获取事务的状态信息
void commit(TransactionStatus status)	提交事务
void rollback(TransactionStatus status)	回滚事务

注意：PlatformTransactionManager 是接口类型，不同的 Dao 层技术则有不同的实现类，例如：Dao 层技术是jdbc 或 mybatis 时：org.springframework.jdbc.datasource.DataSourceTransactionManager

TransactionDefinition

TransactionDefinition 是事务的定义信息对象

方法	说明
int getIsolationLevel()	获得事务的隔离级别
int getPropogationBehavior()	获得事务的传播行为
int getTimeout()	获得超时时间
boolean isReadOnly()	是否只读

事务隔离级别

设置隔离级别，可以解决事务并发产生的问题，如脏读、不可重复读和虚读。

• ISOLATION_DEFAULT
• ISOLATION_READ_UNCOMMITTED
• ISOLATION_READ_COMMITTED
• ISOLATION_REPEATABLE_READ
• ISOLATION_SERIALIZABLE

---

事务传播行为

• REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值）
• SUPPORTS：支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务）
• MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常
• REQUERS_NEW：新建事务，如果当前在事务中，把当前事务挂起。
• NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
• NEVER：以非事务方式运行，如果当前存在事务，抛出异常
• NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行 REQUIRED 类似的操作
• 超时时间：默认值是-1，没有超时限制。如果有，以秒为单位进行设置
• 是否只读：建议查询时设置为只读

---

TransactionStatus

TransactionStatus 接口提供的是事务具体的运行状态

方法	说明
boolean hasSavepoint()	是否存储回滚点
boolean isCompleted()	事务是否完成
boolean isNewTransaction()	是否是新事务
boolean isRollbackOnly()	事务是否回滚

---

基于 XML 的声明式事务控制

声明式事务控制的实现

声明式事务控制明确事项：

1. 谁是切点？
2. 谁是通知？
3. 配置切面？

<!-- 引入tx命名空间
xmlns:tx="http://www.springframework.org/schema/tx"

http://www.springframework.org/schema/tx 
http://www.springframework.org/schema/tx/spring-tx.xsd
 -->

<!-- 配置事务增强 -->
<!--平台事务管理器-->
<bean id="transactionManager" 
class="org.springframework.jdbc.datasourceDataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
</bean>
<!--事务增强配置-->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="*"/>
    </tx:attributes>
</tx:advice>
<!--<tx:method> 代表切点方法的事务参数的配置    
例如：
<tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" timeout="-1" read-only="false"/>
1. name：切点方法名称
2. isolation:事务的隔离级别
3. propogation：事务的传播行为
4. timeout：超时时间
5. read-only：是否只读
-->

<!--配置事务 AOP 织入-->
<!--事务的aop增强-->
<aop:config>
    <aop:pointcut id="myPointcut" expression="execution(* service.impl.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="myPointcut"></aop:advisor>
</aop:config>

---

基于注解的声明式事务控制

略。。。
还是老老实实用xml

END