Spring系列框架的学习-基础篇

Spring框架学习

一、Spring基础

1.1 最基础最核心

IOC（控制反转）：代码中的创建对象，赋值等由代码控制，反转交由容器（Spring是一种容器）控制。
AOP（面向切面），实现模块之间、类之间的解耦合。
Spring容器：容器中存放JAVA对象，由容器进行管理。
Spring：使用的是依赖注入技术，底层使用的是反射机制。

1.2 优点

• 轻量：非常小，没有依赖
• IOC：针对接口编程，减少对象之间的耦合（能够实现业务对象之间的解耦合，例：service与dao对象之间的解耦合）
• AOP：支持AOP编程，将应用程序业务逻辑与系统服务分开。
• 组合框架：容易跟其它的框架一起使用

1.3 Spring的引入

在pom.xml中引入

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.3.20</version>
    </dependency>

1.4 Spring简单实例

由XML文件实现JAVA对象的注入，然后通过读取Spring容器对象，通过key获取指定的对象。默认同一个名称的对象只存在一个（即单例模式）。

实例

• 创建接口

public interface StudyTest {
    void oneTest();
}

• 接口实现

public class StudyTestImpl implements StudyTest {
    @Override
    public void oneTest() {
        System.out.println("调用了StudyTestImpl 的oneTest方法！");
    }
}

• 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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
     <!--
        beans里存放了需要Spring创建的对象。一个bean对应一个创建的对象。
        所有的对象都会存放在Spring的特定Map中，id的值相当于key，class的对象相当于value。Spring相当于执行了map.put("【id的值】",【class的对象】);
        StudyTest studyTest = new StudyTestImpl(); map.put("studyTest",studyTest);
      -->
    
    <bean id="studyTest" class="com.xqj.test.impl.StudyTestImpl" />
</beans>

• 调用
  AplicationContext是一个接口；实现类有FileSystemXmlApplicationContext（从本地磁盘中找寻配置文件的类）和ClassPathXmlApplicationContext（从项目汇总找配置文件）

public class AppTest{
    @Test
    public void test1(){
        String config = "SpringConfig.xml";
        //创建Spring的容器ApplicationContext时，会创建配置中所有的对象。
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(config);
        //从Spring的对象Map中读取指定对象（bean中的ID）
        StudyTest studyTest = (StudyTest) applicationContext.getBean("studyTest");
        studyTest.oneTest();
    }
}

二、Spring学习

2.1 依赖注入（di）

• 开发人员在项目中只需要提供对象的名称，由容器实现对象的创建、查找、赋值。
• 可以在配置文件中对简单数据类型（JAVA的基本数据类型和String类型）进行注入。
• 在创建Spring容器对象时，配置文件的路径默认是以src->main->resources为根目录读取。

2.1.1 注入分类

• 1.set注入（设值注入）：Spring调用类的set方法进行属性赋值。
  1）简单类型的set注入：property name=“属性名” value=“属性值”
  2）引用类型的set注入：property name=“属性名” ref=“引用类型的bean的id”
• 2.构造注入：Spring调用有参构造方法（constructor-arg name=“” value=“” index=“”）
  1）name：表示构造方法的形参名
  2）index：表示构造方法的参数位置，从0开始
• 3.自动注入：由Spring根据一些规则（常用的byName，byType）给引用类型完成赋值
  1）byName：按名称注入，java类中引用类型的属性名和Spring容器中bean的id一样，数据类型一样
  2）byType：按类型注入，java类中引用类型的是数据类型和Spring容器中bean的class同源关系（父子关系）

2.1.2 set注入

1. 简单数据类型的set注入

<property name="属性名" value="属性的值"/>

实例

• 创建实体类

public class User {
    private String name;
    private int age;

    public void setName(String name){
        this.name = name;
    }
    public void setAge(int age){
        this.age = age;
    }
        
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

• 配置文件依赖注入

<bean id="myUser" class="com.xqj.test.pojo.User">
     <property name="name" value="张三"></property>
     <property name="age" value="16"></property>
 </bean>

• 调用

    @Test
    public void test2(){
        String config = "SpringConfig.xml";
        //Spring的对象ApplicationContext
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(config);
        User user = (User) applicationContext.getBean("myUser");
        System.out.println("注入："+user);
    }

• 使用Spring注入，在配置文件中给实体类赋值时，需要实体类中包含set方法。
• 只要类中存在set方法，就可以通过Spring配置注入。

2. 引用类型的set注入

<property name="属性名" ref="引用的bean的ID"/>

实例

• 创建实体类

//公司
public class Company {
    private String name;
    private String address;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    @Override
    public String toString() {
        return "Company{" +
                "name='" + name + '\'' +
                ", address='" + address + '\'' +
                '}';
    }
}

//员工
public class Worker {
    private String name;
    private int age;
    private Company company;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Company getCompany() {
        return company;
    }
    public void setCompany(Company company) {
        this.company = company;
    }

    @Override
    public String toString() {
        return "Worker{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", company=" + company +
                '}';
    }

• 配置

    <bean id="worker" class="com.xqj.test.pojo.Worker">
        <property name="name" value="张三"></property>
        <property name="age" value="22"></property>
        <property name="company" ref="company"></property>
    </bean>
    <bean id="company" class="com.xqj.test.pojo.Company">
        <property name="name" value="张三"></property>
        <property name="address" value="广州"></property>
    </bean>

• 调用

    @Test
    public void test3(){
        String config = "SpringConfig.xml";
        //Spring的对象ApplicationContext
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(config);
        Worker worker = (Worker) applicationContext.getBean("worker");
        System.out.println("注入："+worker);
    }

2.1.3 构造注入

实例

• 实体类

//在Worker类中添加有参构造函数
  public Worker(String myName,int myAge,Company myCompany){
        this.name=myName;
        this.age=myAge;
        this.company=myCompany;
    }

• 配置

    <bean id="company" class="com.xqj.test.pojo.Company">
        <property name="name" value="张三"></property>
        <property name="address" value="广州"></property>
    </bean>

    <bean id="myWorker" class="com.xqj.test.pojo.Worker">
        <!--  name:有参构造函数的参数名；value：参数的值；index：对应参数的位置（name和index其中一个就可以定位到参数）  -->
        <constructor-arg name="myName" value="张三" index="0"/>
        <constructor-arg name="myAge" value="26" index="1"/>
        <constructor-arg name="myCompany" ref="company" index="2"/>
    </bean>

• 调用

    @Test
    public void test3(){
        String config = "SpringConfig.xml";
        //Spring的对象ApplicationContext
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(config);
        //通过bean的ID获取指定的对象
        Worker worker = (Worker) applicationContext.getBean("myWorker");
        System.out.println("注入："+worker);
    }

2.1.4 引用类型的自动注入

Spring框架根据某些规则可以给引用类型赋值，不用再给引用类型赋值，使用的规则常用的是byName和byType

1.byName方式自动注入

• byName(按名称注入):JAVA代码中对象的名称需要与配置文件中bean的ID保持一致，才能实现引用注入。

实例

Worker 实体类的Company 对象定义的名称与配置文件中注入的Company对象bean的ID一致。

• 实体类

public class Worker {
    private String name;
    private int age;
    private Company company;

    public Worker(){}

    public Worker(String myName,int myAge,Company myCompany){
        this.name=myName;
        this.age=myAge;
        this.company=myCompany;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Company getCompany() {
        return company;
    }
    public void setCompany(Company company) {
        this.company = company;
    }
    @Override
    public String toString() {
        return "Worker{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", company=" + company +
                '}';
    }
}

• 配置文件

//定义autowire属性为byName，且引用的类型名称与引用类型的bean的ID一致。
   <bean id="worker" class="com.xqj.test.test01.pojo.Worker"  autowire="byName">
        <property name="name" value="张三"></property>
        <property name="age" value="22"></property>
    </bean>
    <bean id="company" class="com.xqj.test.test01.pojo.Company">
        <property name="name" value="XX有限公司"></property>
        <property name="address" value="广州"></property>
    </bean>

2. byType方式自动注入

bean中定义autowire为byType。引用的类型会根据bean属性class的值（引用类型的地址）找到响应的bean对象。
但是可能会出现不唯一的情况，容易报错。

实例

2.2 注解

使用步骤

• 1.加入依赖：spring-context，间接加入spring-aop
• 2.在类中加入注解
• 3.在spring的配置文件中，加入组件扫描器的标签<context:component-scan base-package=“包名”/>

2.2.1 常用注解

1.列表

注解名	注解作用
@Component	创建对象
@Service	创建Service对象，处理业务逻辑，可以有事务功能
@Repository	创建dao对象，用来访问数据库的
@Controller	创建控制器对象的，接收请求，显示处理结果的
@Resource	JDK（1.6以上）中的注解，使用自动注入给引用类型赋值，支持byName、byType，默认byName
@Autowired	Spring框架中引用类型的赋值注解，支持byName、byType，默认byType
@Value	简单数据类型的赋值

2.描述

• @Component

作用：注解该类为实体类。等同于配置文件的bean功能。
用法：
在定义的类上面添加@Component(value = "")或@Component("")，value是该类的名称，相当于配置文件中的bean标签的id属性。value的值必须是唯一的。或@Component写法，标签为所注解的类首字母小写的名称。
其它能创建对象的注解（以下三个注解除了跟Component一样能创建对象，还有其它功能）：
@Repository（持久层）放在dao的实现类上面，表示创建dao对象（能访问数据库）。
@Service(业务层)放在service的实现类上面，创建service对象（service对象是做业务层处理，可以有事务等功能）。
@Controller（控制器上面）放在控制器（处理器）上面，创建控制器对象（控制器对象能够接收用户提交的请求和最终的处理结果）

• @Value

作用：简单数据类型的赋值（Value是String数据类型）。
用法：@Value(value="")或者@Value("")。在定义的属性上方使用，无需set方法。也可以用在set方法之上。

• @Autowired

作用：Spring框架提供的注解，实现引用类的赋值。使用自动注入的原理，支持byName、byType。默认byType自动注入。
byType的方式： @Autowired，在定义的属性上方使用，无需set方法。也可以用在set方法之上。
byName的方式： @Autowired+@Qualifier("")一起使用。Qualifier是引用对象Component注解定义的名称或者bean引入是的id。
Autowired的required属性：boolean类型，默认为true。
required=true引用类型赋值失败，则报错，并终止程序。
required=false引用类型赋值失败，则程序不报错，继续运行，引用对象为null。

• @Resource

作用：来自JDK1.6以上的注解，Spring框架提供了关于这个注解的功能支持。可以通过它实现对引用类型的赋值。是通过自动注入的原理，支持byName、byType，默认byName。在执行的时候会先按byName的方式执行，执行失败后，会使用byType执行。
用法：
@Resource。在引用类型的上方使用，无需set方法。也可以在set方法上方使用。
@Resource(name=""),只使用byName的方式对引用类型进行赋值。

2.2.2 组件扫描器

• 配置文件标签：

使用规范：<context:component-scan base-package="扫描指定路径下的所有文件"/>
base-package：指定注解在项目中的包名
工作方式：Spring会扫描遍历base-package指定的包，把包中和子包中的所有类，找到类中的注解，按照注解的功能创建对象，或给属性赋值。

2.2.3 JavaConfig类

1.1 JavaConfig类

• JavaConfig：使用java类作为xml配置文件的替代。是配置Spring容器的纯java的方式，在这个java类中可以创建java对象，把对象放入Spring容器中。
• 使用两个注解
  1）@Configuration：放在类的上方，表示该类是作为配置文件的java类使用。
  2）@Bean：声明对象，把对象注入Spring容器中。
• 实例：

//实体类
public class Student {
    private String name;
    private int age;
    private String sex;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex=" + sex +
                '}';
    }

//JavaConfig的java类
@Configuration
public class MyConfig {
    /**
     * @Bean:默认方法名
     *      属性 name：指定自定义名称（bean的名称，相当于配置文件bean标签的id）
     * @return
     */
    @Bean(name="getStudent")
    public Student getStudent(){
        Student student = new Student();
        student.setName("张三");
        student.setAge(18);
        student.setSex("男");
        return student;
    }
}

//单元测试类
public class MyTest01 {
    @Test
    public void test01(){
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
        Student student = (Student) applicationContext.getBean("getStudent");
        System.out.println(student);
    }

1.2 @ImportResource

• @ImportResource：用于导入其它的xml配置文件

• 使用：
  @Configuration
  @ImportResource(value = “classpath:test01/applicationContext.xml”)
  public class MyConfig {}

• 实例：

//实体类
public class User {
    private String userName;
    private String passWord;
    private int number;
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getPassWord() {
        return passWord;
    }
    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
    public int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }
    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", passWord='" + passWord + '\'' +
                ", number=" + number +
                '}';
    }
}

//配置文件
    <bean id="myUser" class="com.xqj.test01.User">
        <property name="userName" value="abc123"/>
        <property name="passWord" value="xqj123"/>
        <property name="number" value="1234567"/>
    </bean>

//JavaConfig的java类（通过@ImportResource引入配置文件）
//多个配置文件 @ImportResource(value = "{classpath:test01/applicationContext.xml，xxxxxx.xml}")
@Configuration
@ImportResource(value = "classpath:test01/applicationContext.xml")
public class MyConfig {

}

//单元测试
    @Test
    public void test02(){
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
        User user = (User) applicationContext.getBean("myUser");
        System.out.println(user);
    }

1.3 @PropertyResource

• @PropertyResource：读取属性配置文件
• 使用：在resources目录下创建config.properties文件，在使用的时候，通过${属性的key}取值
• 实例：

//实体类
@Component("tiger")
public class Tiger {
    @Value("${tiger.name}")
    private String name;
    @Value("${tiger.age}")
    private int age;
}

//配置文件（config.properties）
tiger.name=东北虎
tiger.age=3

//JavaConfig的java类（通过@PropertySource引入自定义文件）
@PropertySource(value="classpath:test01/config.properties") 
@ComponentScan(basePackages = "com.xqj.test01.pojo")  //将目录下的所有类创建对象，并交给Spring容器
public class MyConfig {}

//单元测试
   @Test
    public void test03(){
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
        //实体类@Component("tiger")中定义的名称
        Tiger tiger= (Tiger) applicationContext.getBean("tiger");
        System.out.println(tiger);
    }

2.3 AOP面向切面编程

• AOP（面向切面编程）：
  1.面向切面编程是从动态角度考虑程序运行过程。可通过运行期动态代理实现程序功能的统一维护的一种技术。
  2.AOP就是动态代理的规范化，把动态代理的实现步骤、方式都定义好了，让开发人员用一种统一的方式实现动态代理。
  3.AOP的底层就是采用动态代理模式实现的。采用两种方式代理，JDK的动态代理和CGLIB的动态代理。

• 理解面向切面编程：
  1）需要在分析项目功能时，找出切面（标识增强的功能，非业务功能。比如：日志、事务等）。
  2）合理的安排切面的执行时间（在目标方法前还是方法后）。
  3）合理的安全的切面执行位置，在哪个类，哪个方法增加增强功能。

• AOP开发三要素：
  1）切面的功能代码（切面是做什么功能的）。
  2）切面能执行的位置（pointcut切入点，多个连接点的集合。是对目标对象的多个方法进行增强）。
  3）切面执行的时间（Active通知表示时间，是在目标方法之前还是之后）。

• 应用场景：
  1）需要给类中的方法进行补充功能。原有的类功能不全，由没有源代码的情况下，可以通过AOP进行功能增强。
  2）需要个多个类增加相同的功能，可以通过AOP实现。
  3）需要给业务方法增加日志、事务等非业务的功能。

2.3.1 动态代理

• 动态代理：是指程序在整个运行过程中根本就不存在目标的代理类，目标对象的代理对象只是由代理生成工具（不是真实定义的类）在程序运行时由JVM根据反射等机制动态生成的。代理对象与目标对象的代理关系在程序运行时才确立。
• 作用：1）在目标类源代码不改变的情况下增加功能。2）减少代码的重复。3）专注业务逻辑代码。4）解耦合，将业务代码与非业务代码（日志、事务等）分离。
• 方式：

• 1.Spring：Spring在内部实现了AOP的规范，能做AOP的工作。主要在事务处理时使用。但是过于笨重，很少使用。
• 2.aspectJ：一个开源的专门做AOP的框架，Spring框架中集成了aspectJ框架，可以通过Spring使用aspectJ的功能。
  1）使用xml的配置文件实现。
  2）使用注解，有5个注解。

1.JDK动态代理

使用：通过JDK中的Proxy、Method、InvocationHandler创建代理对象。
注意事项：JDK的动态需要目标对象必须实现接口（java设计上的需求），如果目标类不存在接口，则无法实现。
步骤：

• 1.创建目标类
• 2.创建InvocationHandler接口的实现类，在这个类实现给目标增强的功能
• 3.使用JDK中的类Proxy，创建代理对象，实现创建对象的能力

2.CGLIB动态代理

原理：生成目标类的子类，在子类中重写父类的方法实现增强，这个子类对象就是代理对象。
注意事项：目标必须是能够被继承，即不能是final的类和方法。
优点：CGLIB的代理效率高于JDK，经常应用在框架中（Spring、Hibernate）等。

3.动态代理实例

AspectJ表达式

AspectJ定义了专门的表达式用于指定切入点。

• 表达式的原型是：
  execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)
• 表达式的四个部分：
  execution(访问权限 方法返回值 方法声明(参数) 异常类型)
• 表达式描述
  ? 表示可选的部分，没有则表示为必填的参数。

名称	描述
modifiers-pattern	访问权限类型，比如public、private等
ret-type-pattern	返回值类型
declaring-type-pattern	包名类名
name-pattern(param-pattern)	方法名（参数类型和参数个数）
throws-pattern	抛出异常类型

• 符号意义

符号	意义
*	0至多个任意字符
…	用在方法参数中，表示任意多个参数；用在包名后，表示当前包及其子包路径
+	用在类名后，表示当前类及其子类；用在接口后，表示当前接口及其实现类

• 表达式举例

例子	说明
execution(public * *(…))	指定切入点为：任意公共方法。
execution(* set*(…))	指定切入点为：任何一个方法名以set开始的方法
execution(* com.xyz.service..(…))	指定切入点为：定义在service包中的任意类的任意方法。不包含子包中的类
execution(* com.xyz.service….(…))	指定切入点为：定义在service包或者子包中的任意类的任意方法
execution(* …service*.*(…))	指定切入点为：所有包下的service子包下所有类（接口）中的所有方法

动态代理实例

前置通知@Before

• service业务类

//AspectJ框架是基于JDK的动态代理，所以切面对象必须是接口的实现类。
public interface SomeService {
    void doSome(String name,Integer age);
}

@Service("someService")
public class SomeServiceImpl implements SomeService {
    @Override
    public void doSome(String name,Integer age) {
        //需要在这个目标中进行增强

        System.out.println("---SomeServiceImpl的doSome方法---");
    }
}

• 增强类(aspectJ)

@Aspect
@Component
public class MyAspect {
    /**
     * 方法的定义要求：
     * 1.必须是公共方法（public）
     * 2.方法没有返回值（void）
     * 3.方法名称自定义
     * 4.方法可以没有参数，也可以有参数。如果有参数，则参数不可自定义，需要遵循参数规范。
     */

    /**
     * @Before 前置通知注解
     * 属性value：是切入点表达式，表示切面功能执行的位置（目标方法的前面）
     *
     */
    @Before(value = "execution(public void com.xqj.aop1.service.impl.SomeServiceImpl.doSome(String,Integer))")
    public void doBefore(){
        System.out.println("doBefore增强---方法前执行");
    }

• 配置类

    <!-- <bean id="someService" class="com.xqj.aop1.service.impl.SomeServiceImpl"/>
    <bean id="myAspect" class="com.xqj.aop1.function.aop.MyAspect"/> -->

    <context:component-scan base-package="com.xqj.aop1"/>
    <!--  spectj-autoproxy:会把Spring容器中的所有的目标对象一次性都生成代理对象  -->
    <aop:aspectj-autoproxy/>

• 测试类

@Test
    public void aopTest1(){
        String congfig = "aop01/applicationContext.xml";
        ApplicationContext applicationContext = (ApplicationContext)new ClassPathXmlApplicationContext(congfig);
        SomeService someService = (SomeService)applicationContext.getBean("someService");
        someService.doSome("杰克",12);
    }

JoinPoint通知

JoinPoint：业务方法，要加入切面的业务方法。
作用：可以在通知中方法中获取方法执行的信息，例如：方法名，方法的实参。
JoinPoint参数的值是由框架赋予，必须是第一个位置的参数。

• 前置通知@Before

@Before(value = "execution(public void com.xqj.aop1.service.impl.SomeServiceImpl.doSome(String,Integer))")
public void doBefore1(JoinPoint jp){
        System.out.println("方法的签名："+jp.getSignature());
        System.out.println("方法的名称："+jp.getSignature().getName());
        Object[] objs = jp.getArgs();
        for(Object obj : objs){
            System.out.println("参数的值："+obj);
        }
        System.out.println("doBefore增强---方法前执行");
    }

• 后置通知：@AfterReturning
  属性：

  •  1.value 切入点表达式（execution()）
    

  •  2.returning 自定义的变量，表示目标方法的返回值。自定义变量名必须和通知方法的形参名一致。
    

  特点：

  •  1.在目标方法之后执行
    

  •  2.能够获取到目标方法的返回值，可以根据这个返回值做不同的处理功能。
    

  •  3.可以修改这个返回值。
    

  实例

//定义带有返回值的接口，并实现。 impl实现类代码
    @Override
    public String doOther(String name, Integer age) {
        System.out.println("---SomeServiceImpl的doOther方法---");
        return "doOther";
    }

//添加后置通知。切面类中添加增强方法。
    @AfterReturning(value = "execution(* *..SomeServiceImpl.doOther(String,Integer))",returning = "obj")
    public void doAfter1(JoinPoint jp,Object obj){
        System.out.println("JoinPoint后置通知的方法的定义："+jp.getSignature());
        System.out.println("目标方法doSome之后执行增强方法");
        System.out.println("doAfter1后置通知的returning参数："+obj);
    }

• 环绕通知：@Around
  属性：value 切入点表达式
  特点：

  • 1.功能最强的通知
  • 2.在目标方法的前和后都能增强功能
  • 3.控制目标方法是否被调用执行
  • 4.修改原来的目标方法的执行结果，影响最后的调用结果。
    环绕通知经常做事务，在目标方法之前开启事务，执行目标方法，在目标方法之后提交事务。

  环绕通知等同于JDK动态代理的InvocationHandler接口。参数ProceedingJoinPoint等同于Method。返回值就是目标方法的执行结果，可以被修改。
  实例：

	//定义带有返回值的接口，并实现。 impl实现类代码
    @Override
    public String doEncircle(String name, Integer age) {
        System.out.println("---SomeServiceImpl的doEncircle方法---");
        return "doEncircle";
    }
    
	//添加环绕通知。切面类中添加增强方法。
    @Around(value = "execution(* *..SomeServiceImpl.doEncircle(String,Integer))")
    public Object doEncircle(ProceedingJoinPoint pjp) throws Throwable {
        Object[] objs = pjp.getArgs();
        String name = "";
        if(null != objs && objs.length > 0){
            name = (String)objs[0];
        }
        System.out.println("环绕通知：目标方法之前执行的方法--获取当前时间-"+new Date());
        Object result = null;
        if("汤姆".equals(name)){
            result = pjp.proceed();
        }
        System.out.println("环绕通知：目标方法之后执行的方法--执行某些事物");
        return result;
    }

    @Around(value = "execution(* *..SomeServiceImpl.doEncircle(String,Integer))")
    public Object doEncircle(ProceedingJoinPoint pjp) throws Throwable {
    	//获取目标方法的参数
        Object[] objs = pjp.getArgs();
        String name = "";
        if(null != objs && objs.length > 0){
            name = (String)objs[0];
        }
        //增强内容
        System.out.println("环绕通知：目标方法之前执行的方法--获取当前时间-"+new Date());
        Object result = null;
        //不符合条件，则业务的方法不被执行
        if("汤姆".equals(name)){
            //执行目标的业务方法
            result = pjp.proceed();
        }
        //增强内容
        System.out.println("环绕通知：目标方法之后执行的方法--执行某些事物");
        return result+"1111";
    }

	//调用
    @Test
    public void aopTest3(){
        String congfig = "aop01/applicationContext.xml";
        ApplicationContext applicationContext = (ApplicationContext)new ClassPathXmlApplicationContext(congfig);
        SomeService someService = (SomeService)applicationContext.getBean("someService");
        //相当于直接调用MyAspect的doEncircle方法。MyAspect的doEncircle返回什么，rel等于什么 
        String rel = someService.doEncircle("汤姆",33);
        System.out.println("返回值："+rel);
    }

• 异常通知：@AfterThrowing
  定义格式：

  •   1.public
    

  •   2.没有返回值
    

  •   3.方法名称自定义
    

  •   4.方法有一个Exception，如果有就是JoinPoint
    

  属性：

  •   1.value 切入点
    

  •   2.throwing 自定义的变量，表示目标方法抛出的异常对象。变量名必须和方法的形参名一致
    

  特点：

  •   1.在目标方法抛出异常时执行
    

  •   2.可以做异常的监控程序，监控目标方法执行时是不是有异常。有异常可以通过发短信、发邮件进行通知。
    

效果类似try{}catch(Exception e){},在执行异常时执行异常通知。

• 最终通知：@After
  属性：
  • 1.value 切入点表达式
    特点：
  • 1.总是会被执行
  • 2.在目标方法之后执行
    效果类似try{}catch(Exception e){}finally{}，在finally中执行。

Pointcut管理切入点

• @Pointcut：定义和管理切入点。如果项目中有多个切入点表达式是重复或是可以服用的，都可以使用@Pointcut。
• 属性：value 切入点表达式
• 位置：在自定义方法的上方
• 特点：当使用 @Pointcut定义在一个方法的上面，此时这个方法的名称就是这个切入点表达式的别名。其它通知使用时，value属性使用该方法别名，即可代替切入点表达式。
• 实例：

    @Before(value = "expression()")
    public void function1(){
        System.out.println("执行方法function1");
    }

    @After("expression()")
    public void function2(){
        System.out.println("执行方法function2");
    }

    @Pointcut("execution(* *..SomeServiceImpl.doEncircle(String,Integer))")
    public void expression(){
    }

CGLIB方式

• 目标类没有接口，使用CGLIB动态代理，Spring框架会自定应用cglib。
• 实例：

//切面类
@Aspect
@Component
public class MyAspect2 {
    @Before(value = "expression()")
    public void function1(){
        System.out.println("执行方法function1");
    }

    @After("expression()")
    public void function2(){
        System.out.println("执行方法function2");
    }

    @Pointcut("execution(public void com.xqj.aop1.service.MyService.doSome())")
    public void expression(){
    }
}

//执行类
  @Test
  public void aopTest4(){
      String congfig = "aop01/applicationContext.xml";
      ApplicationContext applicationContext = (ApplicationContext)new ClassPathXmlApplicationContext(congfig);
      MyService myService = (MyService)applicationContext.getBean("myService");
      myService.doSome();
  }

• 如果有接口，但是不用JDK动态代理，而是用CGLIB动态代理，则需要修改配置文件。

	<!--    <aop:aspectj-autoproxy/>-->
    <aop:aspectj-autoproxy proxy-target-class="true"/>