Spring

Spring-day01 IoC

1)Spring简介

1.1)什么是框架

• 源自于建筑学，隶属土木工程，后发展到软件工程领域

• 软件工程框架：经过验证的，具有一定功能的，半成品软件

  • 经过验证

  • 具有一定功能

  • 半成品

1.2)框架的作用

1.3)Spring是什么

Spring是分层的JavaSE/EE应用full-stack轻量级开源框架

1.4)Spring的体系结构

1.5)Spring的发展历史

1.6)Spring优势

Spring的优势
方便解耦，简化开发	第一天
方便集成各种优秀框架	第一天
方便程序的测试	第二天
AOP编程的支持	第三天
声明式事务的支持	第四天
降低JavaEE API的使用难度	第四天
Java源码是经典学习范例	长期学习

2)IoC简介

2.1)优质程序代码的制作原则

2.2)耦合与内聚

• 耦合（Coupling）：代码书写过程中所使用技术的结合紧密度，用于衡量软件中各个模块之间的互联程度

• 内聚（Cohesion）：代码书写过程中单个模块内部各组成部分间的联系，用于衡量软件中各个功能模块内部的功能联系

• 程序书写的目标：高内聚，低耦合
  • 就是同一个模块内的各个元素之间要高度紧密，但是各个模块之间的相互依存度却不要那么紧密

2.3)工厂模式发展史

2.4)Spring发展历程

2.5)IoC

• IoC（Inversion Of Control）控制反转，Spring反向控制应用程序所需要使用的外部资源

• Spring控制的资源全部放置在Spring容器中，该容器称为IoC容器

  

3)入门案例

3.1)案例环境说明

• 模拟三层架构中表现层调用业务层功能

  • 表现层：UserApp模拟UserServlet（使用main方法模拟）

  • 业务层：UserService

3.2)IoC入门案例制作步骤

1.导入spring坐标（5.1.9.release）

2.编写业务层与表现层（模拟）接口与实现类

3.建立spring配置文件

4.配置所需资源（Service）为spring控制的资源

5.表现层（App）通过spring获取资源（Service实例）

3.2.1)IoC入门案例制作步骤-1

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

3.2.2)IoC入门案例制作步骤-2

public interface UserService {
	//业务方法  
	void save();
}

3.2.3)IoC入门案例制作步骤-3

public class UserServiceImpl implements UserService {
    public void save() {
        System.out.println("user service running...");
    }
}

3.2.4)配置文件 IoC入门案例制作步骤-4

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

    <!--配置UserServiceImpl的信息,spring容器根据这些信息创建对象-->
    <!--
        id:作为创建出来的对象的唯一标识
        class:创建出来的对象的类型
    -->
    <bean id="userService" class="com.zyz.service.impl.UserServiceImpl"/>
</beans>

3.2.5)IoC入门案例制作步骤-5

public class UserApp {

    public static void main(String[] args) {
        //获取userserviceimpl 对象 希望从spring容器中获取
        //1.加载配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        //获取想要创建的userservice对象
        UserService userService = (UserService) context.getBean("userService");
        userService.save();
    }
}

4)IoC配置（XML格式）

4.1)bean

• 名称：bean

• 类型：标签

• 归属：beans标签

• 作用：定义spring中的资源，受此标签定义的资源将受到spring控制

• 格式：

  <beans>
  	<bean />
  </beans>
  

• 基本属性：

  <bean id="beanId" name="beanName1,beanName2" class="ClassName"></bean>
  

  ​ id：bean的名称，通过id值获取bean

  ​ class：bean的类型

  ​ name：bean的名称，可以通过name值获取bean，用于多人配合时给bean起别名

4.2)bean属性scope

• 名称：scope

• 类型：属性

• 归属：bean标签

• 作用：定义bean的作用范围

• 格式：

  <bean scope="singleton"></bean>
  

• 取值：

  • singleton：设定创建出的对象保存在spring容器中，是一个单例的对象
  • prototype：设定创建出的对象保存在spring容器中，是一个非单例的对象
  • scope: singleton单例(获取的对象始终是一个) prototype:多例(每次获取对象都会new一个)
  • request、session、application、 websocket ：设定创建出的对象放置在web容器对应的位置

4.3)bean生命周期

• 名称：init-method，destroy-method

• 类型：属性

• 归属：bean标签

• 作用：定义bean对象在初始化或销毁时完成的工作

• 格式：

  <bean init-method="init" destroy-method="destroy></bean>
  

• 取值：bean对应的类中对应的具体方法名

• 注意事项：

  • 当scope=“singleton”时，spring容器中有且仅有一个对象，init方法在创建容器时仅执行一次

  • 当scope=“prototype”时，spring容器要创建同一类型的多个对象，init方法在每个对象创建时均执行一次

  • 当scope=“singleton”时，关闭容器会导致bean实例的销毁，调用destroy方法一次

  • 当scope=“prototype”时，对象的销毁由垃圾回收机制gc()控制，destroy方法将不会被执行==

4.4)bean对象创建方式（了解）

默认使用的是无参构造的形式创建对象

(1)factory-bean

• 名称：factory-bean

• 类型：属性

• 归属：bean标签

• 作用：定义bean对象创建方式，使用静态工厂的形式创建bean，兼容早期遗留系统的升级工作

• 格式：

  <bean class="FactoryClassName" factory-method="factoryMethodName"></bean>
  

• 取值：工厂bean中用于获取对象的静态方法名

• 注意事项：

  • class属性必须配置成静态工厂的类名

(2)factory-bean，factory-method

• 名称：factory-bean，factory-method

• 类型：属性

• 归属：bean标签

• 作用：定义bean对象创建方式，使用实例工厂的形式创建bean，兼容早期遗留系统的升级工作

• 格式：

  <bean factory-bean="factoryBeanId" factory-method="factoryMethodName"></bean>
  

• 取值：工厂bean中用于获取对象的实例方法名

• 注意事项：

  • 使用实例工厂创建bean首先需要将实例工厂配置bean，交由spring进行管理
  • 方法静态就是静态工厂，方法不静态就是实例工厂

<!-- 实例工厂-->
    <!--1.创建工厂对象-->
    <bean id="factory" class="com.factory.UserServiceFactory"></bean>
    <!--2.获取对象-->
    <!--
        factory-bean:指明哪个工厂创建
        factory-method:指明该工厂的哪个方法创建
    -->
    <bean id="userService" factory-bean="factory" factory-method="getUserService"></bean>

• factory-bean是实例工厂的beanId

4.5)DI

• IoC（Inversion Of Control）控制翻转，Spring反向控制应用程序所需要使用的外部资源

• DI（Dependency Injection）依赖注入，应用程序运行依赖的资源由Spring为其提供，资源进入应用程序的方式称为注入

IoC与DI的关系

• IoC与DI是同一件事站在不同角度看待问题

• 半杯水

set注入（主流）

4.6)set注入（主流）

• 名称：property

• 类型：标签

• 归属：bean标签

• 作用：使用set方法的形式为bean提供资源

• 格式：

  <bean>
  	<property />
  </bean>
  

• 基本属性：

  <property name="propertyName" value="propertyValue" ref="beanId"/>
  

​ name：对应bean中的属性名，要求该属性必须提供可访问的set方法（严格规范为此名称是set方法对应名称）

​ value：设定非引用类型属性对应的值，不能与ref同时使用

​ ref：设定引用类型属性对应bean的id ，不能与value同时使用

• 注意：一个bean可以有多个property标签

<!--在注入userDao对象的时候，首先要创建一个userDao对象，注入对象方法一样-->
<bean id="userDao" class="com.dao.UserDaoImpl"></bean>
<!--创建对象的过程中给属性赋值-->
 <!--set方式-->
<bean id="userService" class="com.service.UserServiceImpl">
        <property name="name" value="tom"></property>
        <property name="age" value="20"></property>
        <property name="userDao" ref="userDao"></property>
    </bean>

public class UserServiceImpl implements UserService{
    private String name;
    private Integer age;

    private UserDao userDao;

    public UserServiceImpl(String name, Integer age, UserDao userDao) {
        this.name = name;
        this.age = age;
        this.userDao = userDao;
    }

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

    public void setAge(Integer age) {
        this.age = age;
    }

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

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

4.7)构造器注入（了解）

• 名称：constructor-arg

• 类型：标签

• 归属：bean标签

• 作用：使用构造方法的形式为bean提供资源，兼容早期遗留系统的升级工作

• 首先要有一个有参构造器

public UserServiceImpl(String name, Integer age, UserDao userDao) {
        this.name = name;
        this.age = age;
        this.userDao = userDao;
    }

• 格式：

  <!--构造器注入-->
    <bean id="userService" class="com.service.UserServiceImpl">
       <!-- <constructor-arg name="name" value="jack"></constructor-arg>
        <constructor-arg name="age" value="10"></constructor-arg>
        <constructor-arg name="userDao" ref="userDao"></constructor-arg>-->
        
          <!--序号为有参构造器的属性顺序注入-->
        <constructor-arg index="0" value="siri"></constructor-arg>
        <constructor-arg index="1" value="5"></constructor-arg>
        <constructor-arg index="2" ref="userDao"></constructor-arg>
    </bean>
  

• 基本属性：

  <constructor-arg name="argsName" value="argsValue />
  

​ name：对应bean中的构造方法所携带的参数名

​ value：设定非引用类型构造方法参数对应的值，不能与ref同时使用

其他属性：

<constructor-arg index="arg-index" type="arg-type" ref="beanId"/>

​ ref：设定引用类型构造方法参数对应bean的id ，不能与value同时使用

​ type ：设定构造方法参数的类型，用于按类型匹配参数或进行类型校验

​ index ：设定构造方法参数的位置，用于按位置匹配参数，参数index值从0开始计数

• 注意：一个bean可以有多个constructor-arg标签

4.8)集合类型数据注入

• 名称：array，list，set，map，props

• 类型：标签

• 归属：property标签 或 constructor-arg标签

• 作用：注入集合数据类型属性

• 格式：

  <property>
  	<list></list>
  </property>
  

(1)集合类型数据注入——list

<!--list集合赋值-->
<property name="list">
    <list>
        <value>tom</value>
        <value>jack</value>
        <value>siri</value>
    </list>
</property>

(2)集合类型数据注入——props

<property name="properties">
    <props>
        <prop key="name">yll666</prop>
        <prop key="value">666666</prop>
    </props>
</property>

(3)集合类型数据注入——array （了解）

<property name="arr">
    <array>
        <value>123456</value>
        <value>66666</value>
    </array>
</property>

(4)集合类型数据注入——set（了解）

 <property name="hs">
     <set>
         <value>yll</value>
         <value>66666</value>
     </set>
</property>

(5)集合类型数据注入——map（了解）

<property name="hm">
    <map>
        <entry key="name" value="yll66666"/>
        <entry key="value" value="6666666666"/>
    </map>
</property>

4.9)使用p命名空间简化配置（了解）

• 名称：p:propertyName，p:propertyName-ref

• 类型：属性

• 归属：bean标签

• 作用：为bean注入属性值

• 格式：

  <bean p:propertyName="propertyValue" p:propertyName-ref="beanId"/>
  

• 注意：使用p命令空间需要先开启spring对p命令空间的的支持，在beans标签中添加对应空间支持

  <beans xmlns="http://www.springframework.org/schema/beans"    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"    xmlns:p="http://www.springframework.org/schema/p"       xsi:schemaLocation="http://www.springframework.org/schema/beans     https://www.springframework.org/schema/beans/spring-beans.xsd">
  

  后续课程中还将开启其他的命名空间，方式同上

• 案例：

   <bean
         id="userService"
         class="com.yll.service.impl.UserServiceImpl"
         p:userDao-ref="userDao"
         p:bookDao-ref="bookDao"
         />
  

4.10)SpEL （了解）

• Spring提供了对EL表达式的支持，统一属性注入格式

• 类型：属性值

• 归属：value属性值

• 作用：为bean注入属性值

• 格式：

  <property value="EL"></bean>
  

• 注意：所有属性值不区分是否引用类型，统一使用value赋值

• 所有格式统一使用 value=“********”

  • 常量 #{10} #{3.14} #{2e5} #{‘itcast’}

  • 引用bean #{beanId}

  • 引用bean属性 #{beanId.propertyName}

  • 引用bean方法 beanId.methodName().method2()

  • 引用静态方法 T(java.lang.Math).PI

  • 运算符支持 #{3 lt 4 == 4 ge 3}

  • 正则表达式支持 #{user.name matches‘[a-z]{6,}’}

  • 集合支持 #{likes[3]}

• 案例：

   <bean id="userService" class="com.yll.service.impl.UserServiceImpl">
       <property name="userDao" value="#{userDao}"/>
       <property name="bookDao" value="#{bookDao}"/>
       <property name="num" value="#{666666666}"/>
       <property name="version" value="#{'itcast'}"/>
  </bean>
  

4.11)properties文件

• Spring提供了读取外部properties文件的机制，使用读取到的数据为bean的属性赋值

• 操作步骤

  1.准备外部properties文件

  2.开启context命名空间支持

  xmlns:context="http://www.springframework.org/schema/context"
  

​ 3.加载指定的properties文件

<context:property-placeholder location="classpath:filename.properties">

​ 4.使用加载的数据

<property name="propertyName" value="${propertiesName}"/>

• 注意：如果需要加载所有的properties文件，可以使用*.properties表示加载所有的properties文件

• 注意：读取数据使用**${propertiesName}格式进行，其中propertiesName**指properties文件中的属性名

4.12)团队开发

• 名称：import

• 类型：标签

• 归属：beans标签

• 作用：在当前配置文件中导入其他配置文件中的项

• 格式：

  <beans>
      <import />
  </beans>
  

• 基本属性：

  <import resource=“config.xml"/>
  

​ resource：加载的配置文件名

• Spring容器加载多个配置文件

  new ClassPathXmlApplicationContext("config1.xml","config2.xml");
  

• Spring容器中的bean定义冲突问题

  • 同id的bean，后定义的覆盖先定义的

  • 导入配置文件可以理解为将导入的配置文件复制粘贴到对应位置

  • 导入配置文件的顺序与位置不同可能会导致最终程序运行结果不同

4.13)ApplicationContext

1.ApplicationContext是一个接口，提供了访问spring容器的API

2.ClassPathXmlApplicationContext是一个类，实现了上述功能

3.ApplicationContext的顶层接口是BeanFactory

4.BeanFactory定义了bean相关的最基本操作

5.ApplicationContext在BeanFactory基础上追加了若干新功能

对比BeanFactory

1.BeanFactory创建的bean采用延迟加载形式，使用才创建

2.ApplicationContext创建的bean默认采用立即加载形式

FileSystemXmlApplicationContext

可以加载文件系统中任意位置的配置文件，而ClassPathXmlApplicationContext只能加载类路径下的配置文件

BeanFactory

Resource res = new ClassPathResource("applicationContext.xml");
BeanFactory bf = new XmlBeanFactory(res);
UserService userService = (UserService)bf.getBean("userService");

4.14)第三方资源配置

• 阿里数据源方案Druid

  <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
      <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
      <property name="url" value="jdbc:mysql://localhost:3306/spring_ioc"></property>
      <property name="username" value="root"></property>
      <property name="password" value="root"></property>
  </bean>
  

注解开发

1)注解驱动的意义

1.1)什么是注解驱动

注解启动时使用注解的形式替代xml配置，将繁杂的spring配置文件从工程中彻底消除掉，简化书写

1.2)注解驱动的弊端

• 为了达成注解驱动的目的，可能会将原先很简单的书写，变的更加复杂

• XML中配置第三方开发的资源是很方便的，但使用注解驱动无法在第三方开发的资源中进行编辑，因此会增大开发工作量

2)常用注解

2.1)启动注解功能

• 启动注解扫描，加载类中配置的注解项

  <context:component-scan base-package="packageName"/>
  

• 说明：

  • 在进行包所扫描时，会对配置的包及其子包中所有文件进行扫描

  • 扫描过程是以文件夹递归迭代的形式进行的

  • 扫描过程仅读取合法的java文件

  • 扫描时仅读取spring可识别的注解

  • 扫描结束后会将可识别的有效注解转化为spring对应的资源加入IoC容器

• 注意：

  • 无论是注解格式还是XML配置格式，最终都是将资源加载到IoC容器中，差别仅仅是数据读取方式不同

  • 从加载效率上来说注解优于XML配置文件

2.2)bean的定义

• 名称：@Component @Controller @Service @Repository

• 类型：类注解

• 位置：类定义上方

• 作用：设置该类为spring管理的bean

• 范例：

  @Component
  public class ClassName{}
  

• 说明：

  • @Controller、@Service 、@Repository是@Component的衍生注解，功能同@Component

• 相关属性

  • value（默认）：定义bean的访问id

2.3)bean的作用域

• 名称：@Scope

• 类型：类注解

• 位置：类定义上方

• 作用：设置该类作为bean对应的scope属性

• 范例：

  @Scope
  public class ClassName{}
  

• 相关属性

  • value（默认）：定义bean的作用域，默认为singleton

2.4)bean的生命周期

• 名称：@PostConstruct、@PreDestroy

• 类型：方法注解

• 位置：方法定义上方

• 作用：设置该类作为bean对应的生命周期方法

• 范例：

  @PostConstruct
  public void init() { System.out.println("init..."); }
  

2.5)bean的非引用类型属性注入

• 名称：@Value

• 类型：属性注解、方法注解

• 位置：属性定义上方，方法定义上方

• 作用：设置对应属性的值或对方法进行传参

• 范例：

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

• 说明：

  • value值仅支持非引用类型数据，赋值时对方法的所有参数全部赋值

  • value值支持读取properties文件中的属性值，通过类属性将properties中数据传入类中

  • value值支持SpEL

  • @value注解如果添加在属性上方，可以省略set方法（set方法的目的是为属性赋值）

• 相关属性

  • value（默认）：定义对应的属性值或参数值

2.6)bean的引用类型属性注入

• 名称：@Autowired、@Qualifier

• 类型：属性注解、方法注解

• 位置：属性定义上方，方法定义上方

• 作用：设置对应属性的对象或对方法进行引用类型传参

• 范例：

  @Autowired(required = false)
  @Qualifier("userDao")
  private UserDao userDao;
  

• 说明：

  • @Autowired默认按类型装配，指定@Qualifier后可以指定自动装配的bean的id

• 相关属性

  • required：定义该属性是否允许为null

2.7)bean的引用类型属性注入

• 名称：@Resource

• 说明：

  • @Resource是JSR250规范中的注解，可以简化书写格式

• @Resource相关属性

  • name：设置注入的bean的id

  • type：设置注入的bean的类型，接收的参数为Class类型

2.10)加载properties文件

• 名称：@PropertySource

• 类型：类注解

• 位置：类定义上方

• 作用：加载properties文件中的属性值

• 范例：

  @PropertySource(value = "classpath:filename.properties")
  public class ClassName {
      @Value("${propertiesAttributeName}")
      private String attributeName;
  }
  

• 说明：

  • 不支持*通配格式，一旦加载，所有spring控制的bean中均可使用对应属性值

• 相关属性

  • value（默认）：设置加载的properties文件名

  • ignoreResourceNotFound：如果资源未找到，是否忽略，默认为false

)综合案例改版（注解整合Junit）

1.Spring接管Junit的运行权，使用Spring专用的Junit类加载器

2.为Junit测试用例设定对应的spring容器：

• 从Spring5.0以后，要求Junit的版本必须是4.12及以上

• Junit仅用于单元测试，不能将Junit的测试类配置成spring的bean，否则该配置将会被打包进入工程中

导入Spring整合Junit坐标

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.1.9.RELEASE</version>
</dependency>

Spring整合Junit测试用例注解格式

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class UserServiceTest {
}

动态代理

1. JDK动态代理

JDKProxy动态代理是针对对象做代理，要求原始对象具有接口实现，并对接口方法进行增强

基于接口的动态代理：
涉及的类：Proxy
提供者：JDK官方
如何创建代理对象：
使用Proxy类中的newProxyInstance方法
创建代理对象的要求：
被代理类最少实现一个接口，如果没有则不能使用
newProxyInstance方法的参数：
ClassLoader：类加载器
它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法。
Class[]：字节码数组
它是用于让代理对象和被代理对象有相同方法。固定写法。
InvocationHandler：用于提供增强的代码
它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
此接口的实现类都是谁用谁写。

public interface Iproducer {

    //买电脑
    void sale(double money);

    //售后
    void afterService();
}

public class Producer implements  Iproducer{
    @Override
    public void sale(double money) {
        System.out.println("买电脑了,价格:"+money);
    }

    @Override
    public void afterService() {
        System.out.println("提供售后服务");
    }
}

public class Client {
    public static void main(String[] args) {
        final Producer producer = new Producer();

        //创建代理商
//        newProxyInstance方法的参数：
    //        ClassLoader：类加载器
    //          它是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法。
    //        Class[]：字节码数组
    //          它是用于让代理对象和被代理对象有相同方法。固定写法。
    //        InvocationHandler：用于提供增强的代码
    //          它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
    //          此接口的实现类都是谁用谁写。
        Iproducer iproducer = (Iproducer) Proxy.newProxyInstance(
                producer.getClass().getClassLoader(),
                producer.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     *
                     * @param proxy  代理对象的引用
                     * @param method 当前执行的方法
                     * @param args  当前执行的方法所需要的参数
                     * @return      和当前代理对象方法相同的返回值
                     * @throws Throwable
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //增强代码
                        Object retuenValue = null;


                        //1.判断当前执行的方法是不是买电脑的方法
                        if("sale".equals(method.getName())){
                            double money = (double) args[0];
                            //是
                            System.out.println("专车接送");
                            retuenValue = method.invoke(producer,money*0.8);
                            System.out.println("送鼠标");
                        }else{
                            //不是,不做任何增强
                            retuenValue = method.invoke(producer,args);
                        }

                        return retuenValue;
                    }
                });

        iproducer.sale(8000.00);
        iproducer.afterService();

    }
}

2. CGLIB动态代理

CGLIB(Code Generation Library)，Code生成类库
CGLIB动态代理不限定是否具有接口，可以对任意操作进行增强

基于子类的动态代理：
涉及的类：Enhancer
提供者：第三方cglib库
如何创建代理对象：
使用Enhancer类中的create方法
创建代理对象的要求：
被代理类不能是最终类
create方法的参数：
Class：字节码
它是用于指定被代理对象的字节码。
Callback：用于提供增强的代码
它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
此接口的实现类都是谁用谁写。 我们一般写的都是该接口的子接口实现类：MethodInterceptor

public class Producer {

    public void sale(double money) {
        System.out.println("买电脑了,价格:"+money);
    }

    public void afterService() {
        System.out.println("提供售后服务");
    }
}

public class Test {
    public static void main(String[] args) {
        final Producer producer = new Producer(); //被代理对象
        /*基于子类的动态代理：
        涉及的类：Enhancer
        提供者：第三方cglib库
        如何创建代理对象：
        使用Enhancer类中的create方法
        创建代理对象的要求：
        被代理类不能是最终类
        create方法的参数：
        Class：字节码
        它是用于指定被代理对象的字节码。
        Callback：用于提供增强的代码
        它是让我们写如何代理。我们一般都是些一个该接口的实现类，通常情况下都是匿名内部类，但不是必须的。
        此接口的实现类都是谁用谁写。 我们一般写的都是该接口的子接口实现类：MethodInterceptor
*/
        Producer producer_cglib = (Producer) Enhancer.create(producer.getClass(), new MethodInterceptor() {

            //实现intercept方法, 代理对象调用任何方法都会执行intercept方法
            /**
             *
             * @param o  代理对象的引用
             * @param method  当前执行的方法
             * @param objects  前执行的方法所需要的参数
             *
             * @param methodProxy  当前执行的方法的代理对象
             * @return
             * @throws Throwable
             */
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                //增强代码
                Object retuenValue = null;

                //1.判断当前执行的方法是不是买电脑的方法
                if("sale".equals(method.getName())){
                    double money = (double) objects[0];
                    //是
                    System.out.println("专车接送");
                    retuenValue = method.invoke(producer,money*0.8);
                    System.out.println("送鼠标");
                }else{
                    //不是,不做任何增强
                    retuenValue = method.invoke(producer,args);
                }

                return retuenValue;
            }
        });

        producer_cglib.sale(8000.00);
    }
}

AOP

1)AOP简介

1.1)AOP概念

• AOP(Aspect Oriented Programing)面向切面编程，一种编程范式，隶属于软工范畴，指导开发者如何组织程序结构

• AOP弥补了OOP的不足，基于OOP基础之上进行横向开发

  • uOOP规定程序开发以类为主体模型，一切围绕对象进行，完成某个任务先构建模型

  • uAOP程序开发主要关注基于OOP开发中的共性功能，一切围绕共性功能进行，完成某个任务先构建可能遇到的所有共性功能（当所有功能都开发出来也就没有共性与非共性之分）

• 简单的说它就是把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。

1.2)AOP作用

• 伴随着AOP时代的降临，可以从各个行业的标准化、规范化开始入手，一步一步将所有共性功能逐一开发完毕，最终以功能组合来完成个别业务模块乃至整体业务系统的开发

• 目标：将软件开发由手工制作走向半自动化/全自动化阶段，实现“插拔式组件体系结构”搭建

1.3)AOP优势

• 提高代码的可重用性

• 业务代码编码更简洁

• 业务代码维护更高效

• 业务功能扩展更便捷

2)AOP入门案例

2.1)AOP相关概念

• Joinpoint(连接点)：就是方法

• Pointcut(切入点)：就是挖掉共性功能的方法

• Advice(通知)：就是共性功能，最终以一个方法的形式呈现

• Aspect(切面)：就是共性功能与挖的位置的对应关系

• Target(目标对象)：就是挖掉功能的方法对应的类产生的对象，这种对象是无法直接完成最终工作的

• Weaving(织入)：就是将挖掉的功能回填的动态过程

• Proxy(代理)：目标对象无法直接完成工作，需要对其进行功能回填，通过创建原始对象的代理对象实现

• Introduction(引入/引介) ：就是对原始对象无中生有的添加成员变量或成员方法

2.2)AOP开发过程

• 开发阶段(开发者完成)

  • 正常的制作程序

  • 将非共性功能开发到对应的目标对象类中，并制作成切入点方法

  • 将共性功能独立开发出来，制作成通知

  • 在配置文件中，声明切入点

  • 在配置文件中，声明切入点与通知间的关系（含通知类型），即切面

• 运行阶段(AOP完成)

  • Spring容器加载配置文件，监控所有配置的切入点方法的执行

  • 当监控到切入点方法被运行，使用代理机制，动态创建目标对象的代理对象，根据通知类别，在代理对象的对应位置将通知对应的功能织入，完成完整的代码逻辑并运行

2.2)AOP开发方式

• XML方式

• XML+注解方式

• 注解方式

2.3)入门案例制作分析

1.导入相关坐标

2.确认要抽取的功能，并将其制作成方法保存到专用的类中，删除原始业务中对应的功能

3.将所有进行AOP操作的资源加载到IoC容器中

4.使用配置的方式描述被抽取功能的位置，并描述被抽取功能与对应位置的关系

5.运行程序

步骤一 导入坐标

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

步骤二 在业务层抽取通用代码

步骤三 把通知加入spring容器管理 @Service

步骤四 在配置文件中配置aop的配置

<!--aop配置-->
<aop:config>
    <!--配置切入点-->
    <aop:pointcut id="pt" expression="execution(* *..*())"/>
    <!--配置切面-->
    <aop:aspect ref="myAdvice">
        <!—通知与切入点之间的关系-->
        <aop:before method="logAdvice" pointcut-ref="pt"/>
    </aop:aspect>
</aop:config>

3)AOP配置（XML）

3.1)AspectJ

• Aspect（切面）用于描述切入点与通知间的关系，是AOP编程中的一个概念

• AspectJ是基于java语言对Aspect的实现

3.2)AOP配置

3.2.1)aop:config

• 名称：aop:config

• 类型：标签

• 归属：beans标签

• 作用：设置AOP

• 格式：

  <beans>
      <aop:config>……</aop:config>
      <aop:config>……</aop:config>
  </beans>
  

• 说明：一个beans标签中可以配置多个aop:config标签

3.2.2)aop:aspect

• 名称：aop:aspect

• 类型：标签

• 归属：aop:config标签

• 作用：设置具体的AOP通知对应的切入点

• 格式：

  <aop:config>
      <aop:aspect ref="beanId">……</aop:aspect>
      <aop:aspect ref="beanId">……</aop:aspect>
  </aop:config>
  

• 说明：

  一个aop:config标签中可以配置多个aop:aspect标签

• 基本属性：

  • ref ：通知所在的bean的id

3.2.3)aop:pointcut

• 名称：aop:pointcut

• 类型：标签

• 归属：aop:config标签、aop:aspect标签

• 作用：设置切入点

• 格式：

  <aop:config>
      <aop:pointcut id="pointcutId" expression="……"/>
      <aop:aspect>
          <aop:pointcut id="pointcutId" expression="……"/>
      </aop:aspect>
  </aop:config>
  

• 说明：

  一个aop:config标签中可以配置多个aop:pointcut标签，且该标签可以配置在aop:aspect标签内

• 基本属性：

  • id ：识别切入点的名称

  • expression ：切入点表达式

3.3)切入点

• 切入点描述的是某个方法

• 切入点表达式是一个快速匹配方法描述的通配格式，类似于正则表达式

3.4)切入点表达式的组成

• 切入点描述的是某个方法

• 切入点表达式是一个快速匹配方法描述的通配格式，类似于正则表达式

  关键字（访问修饰符  返回值  包名.类名.方法名（参数）异常名）
  

​ 关键字：描述表达式的匹配模式（参看关键字列表）

​ 访问修饰符：方法的访问控制权限修饰符

​ 类名：方法所在的类（此处可以配置接口名称）

​ 异常：方法定义中指定抛出的异常

• 范例：

  execution（public User com.yll.service.UserService.findById（int））
  

3.4.1)切入点表达式——关键字

• execution ：匹配执行指定方法

3.4.2)切入点表达式——通配符

• *：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现

  execution（public * com.yll.*.UserService.find*（*））
  

​ 匹配com.yll包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法

• … ：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写

  execution（public User com..UserService.findById（..））
  

​ 匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法

• +：专用于匹配子类类型

  execution(* *..*Service+.*(..))
  

3.4.3)切入点表达式——逻辑运算符

• && ：连接两个切入点表达式，表示两个切入点表达式同时成立的匹配

• || ：连接两个切入点表达式，表示两个切入点表达式成立任意一个的匹配

• ! ：连接单个切入点表达式，表示该切入点表达式不成立的匹配

3.4.4)切入点表达式——范例

execution(* *(..))
execution(* *..*(..))
execution(* *..*.*(..))
execution(public * *..*.*(..))
execution(public int *..*.*(..))
execution(public void *..*.*(..))
execution(public void com..*.*(..)) 
execution(public void com..service.*.*(..))
execution(public void com.yll.service.*.*(..))
execution(public void com.yll.service.User*.*(..))
execution(public void com.yll.service.*Service.*(..))
execution(public void com.yll.service.UserService.*(..))
execution(public User com.yll.service.UserService.find*(..))
execution(public User com.yll.service.UserService.*Id(..))
execution(public User com.yll.service.UserService.findById(..))
execution(public User com.yll.service.UserService.findById(int))
execution(public User com.yll.service.UserService.findById(int,int))
execution(public User com.yll.service.UserService.findById(int,*))
execution(public User com.yll.service.UserService.findById(*,int))
execution(public User com.yll.service.UserService.findById())
execution(List com.yll.service.*Service+.findAll(..))

3.5)切入点的三种配置方式

<aop:config>
    <!--配置公共切入点-->
    <aop:pointcut id="pt1" expression="execution(* *(..))"/>
    <aop:aspect ref="myAdvice">
        <!--配置局部切入点-->
        <aop:pointcut id="pt2" expression="execution(* *(..))"/>
        <!--引用公共切入点-->
        <aop:before method="logAdvice" pointcut-ref="pt1"/>
        <!--引用局部切入点-->
        <aop:before method="logAdvice" pointcut-ref="pt2"/>
        <!--直接配置切入点-->
        <aop:before method="logAdvice" pointcut="execution(* *(..))"/>
    </aop:aspect>
</aop:config>

3.6)切入点配置经验

• 企业开发命名规范严格遵循规范文档进行

• 先为方法配置局部切入点

• 再抽取类中公共切入点

• 最后抽取全局切入点

• 代码走查过程中检测切入点是否存在越界性包含

• 代码走查过程中检测切入点是否存在非包含性进驻

• 设定AOP执行检测程序，在单元测试中监控通知被执行次数与预计次数是否匹配

• 设定完毕的切入点如果发生调整务必进行回归测试

（以上规则适用于XML配置格式）

3.7)通知类型

AOP的通知类型共5种

• 前置通知：原始方法执行前执行，如果通知中抛出异常，阻止原始方法运行

  应用：数据校验

• 后置通知：原始方法执行后执行，无论原始方法中是否出现异常，都将执行通知

  应用：现场清理

• 返回后通知：原始方法正常执行完毕并返回结果后执行，如果原始方法中抛出异常，无法执行

  应用：返回值相关数据处理

• 抛出异常后通知：原始方法抛出异常后执行，如果原始方法没有抛出异常，无法执行

  应用：对原始方法中出现的异常信息进行处理

• 环绕通知：在原始方法执行前后均有对应执行执行，还可以阻止原始方法的执行

  应用：十分强大，可以做任何事情

3.7.1)aop:before

• 名称：aop:before

• 类型：标签

• 归属：aop:aspect标签

• 作用：设置前置通知

• 格式：

  <aop:aspect ref="adviceId">
      <aop:before method="methodName" pointcut="……"/>
  </aop:aspect>
  

• 说明：一个aop:aspect标签中可以配置多个aop:before标签

• 基本属性：

  • method ：在通知类中设置当前通知类别对应的方法

  • pointcut ：设置当前通知对应的切入点表达式，与pointcut-ref属性冲突

  • pointcut-ref ：设置当前通知对应的切入点id，与pointcut属性冲突

3.7.2)aop:after

• 名称：aop:after

• 类型：标签

• 归属：aop:aspect标签

• 作用：设置后置通知

• 格式：

  <aop:aspect ref="adviceId">
      <aop:after method="methodName" pointcut="……"/>
  </aop:aspect>
  

• 说明：一个aop:aspect标签中可以配置多个aop:after标签

• 基本属性：

  • method ：在通知类中设置当前通知类别对应的方法

  • pointcut ：设置当前通知对应的切入点表达式，与pointcut-ref属性冲突

  • pointcut-ref ：设置当前通知对应的切入点id，与pointcut属性冲突

3.7.3)aop:after-returning

• 名称：aop:after-returning

• 类型：标签

• 归属：aop:aspect标签

• 作用：设置返回后通知

• 格式：

  <aop:aspect ref="adviceId">
      <aop:after-returning method="methodName" pointcut="……"/>
  </aop:aspect>
  

• 说明：一个aop:aspect标签中可以配置多个aop:after-returning标签

• 基本属性：

  • method ：在通知类中设置当前通知类别对应的方法

  • pointcut ：设置当前通知对应的切入点表达式，与pointcut-ref属性冲突

  • pointcut-ref ：设置当前通知对应的切入点id，与pointcut属性冲突

3.7.4)aop:after-throwing

• 名称：aop:after-throwing

• 类型：标签

• 归属：aop:aspect标签

• 作用：设置抛出异常后通知

• 格式：

  <aop:aspect ref="adviceId">
      <aop:after-throwing method="methodName" pointcut="……"/>
  </aop:aspect>
  

• 说明：一个aop:aspect标签中可以配置多个aop:after-throwing标签

• 基本属性：

  • method ：在通知类中设置当前通知类别对应的方法

  • pointcut ：设置当前通知对应的切入点表达式，与pointcut-ref属性冲突

  • pointcut-ref ：设置当前通知对应的切入点id，与pointcut属性冲突

3.7.5)aop:around

• 名称：aop:around

• 类型：标签

• 归属：aop:aspect标签

• 作用：设置环绕通知

• 格式：

  <aop:aspect ref="adviceId">
      <aop:around method="methodName" pointcut="……"/>
  </aop:aspect>
  

• 说明：一个aop:aspect标签中可以配置多个aop:around标签

• 基本属性：

  • method ：在通知类中设置当前通知类别对应的方法

  • pointcut ：设置当前通知对应的切入点表达式，与pointcut-ref属性冲突

  • pointcut-ref ：设置当前通知对应的切入点id，与pointcut属性冲突

环绕通知的开发方式

• 环绕通知是在原始方法的前后添加功能，在环绕通知中，存在对原始方法的显式调用

  public Object around(ProceedingJoinPoint pjp) throws Throwable {
      Object ret = pjp.proceed();
      return ret;
  }
  

• 环绕通知方法相关说明：

  • 方法须设定Object类型的返回值，否则会拦截原始方法的返回。如果原始方法返回值类型为void，通知方 也可以设定返回值类型为void，最终返回null

  • 方法需在第一个参数位置设定ProceedingJoinPoint对象，通过该对象调用proceed()方法，实现对原始方法的调用。如省略该参数，原始方法将无法执行

  • 使用proceed()方法调用原始方法时，因无法预知原始方法运行过程中是否会出现异常，强制抛出Throwable对象，封装原始方法中可能出现的异常信息

3.8)通知顺序（了解）

当同一个切入点配置了多个通知时，通知会存在运行的先后顺序，该顺序以通知配置的顺序为准

4)AOP配置（注解）

4.1)AOP配置

4.2)注解开发AOP制作步骤

在XML格式基础上

• 导入坐标（伴随spring-context坐标导入已经依赖导入完成）

• 开启AOP注解支持

• 配置切面@Aspect

• 定义专用的切入点方法，并配置切入点@Pointcut

• 为通知方法配置通知类型及对应切入点@Before

4.3)注解开发AOP注意事项

1.切入点最终体现为一个方法，无参无返回值，无实际方法体内容，但不能是抽象方法

2.引用切入点时必须使用方法调用名称，方法后面的（）不能省略

3.切面类中定义的切入点只能在当前类中使用，如果想引用其他类中定义的切入点使用“类名.方法名()”引用

4.4)AOP注解详解

4.4.1)@Aspect

• 名称：@Aspect

• 类型：注解

• 位置：类定义上方

• 作用：设置当前类为切面类

• 格式：

  @Aspect
  public class AopAdvice {
  }
  

• 说明：一个beans标签中可以配置多个aop:config标签

4.4.2)@Pointcut

• 名称：@Pointcut

• 类型：注解

• 位置：方法定义上方

• 作用：使用当前方法名作为切入点引用名称

• 格式：

  @Pointcut("execution(* *(..))")
  public void pt() {
  }
  

• 说明：被修饰的方法忽略其业务功能，格式设定为无参无返回值的方法，方法体内空实现（非抽象）

4.4.3)@Before

• 名称：@Before

• 类型：注解

• 位置：方法定义上方

• 作用：标注当前方法作为前置通知

• 格式：

  @Before("pt()")
  public void before(){
  }
  

• 特殊参数：

  • 无

4.4.4)@After

• 名称：@After

• 类型：注解

• 位置：方法定义上方

• 作用：标注当前方法作为后置通知

• 格式：

  @After("pt()")
  public void after(){
  }
  

• 特殊参数：

  • 无

4.4.5)@AfterReturning

• 名称：@AfterReturning

• 类型：注解

• 位置：方法定义上方

• 作用：标注当前方法作为返回后通知

• 格式：

  @AfterReturning(value="pt()")
  public void afterReturning(Object ret) {
  }
  

4.4.6)@AfterThrowing

• 名称：@AfterThrowing

• 类型：注解

• 位置：方法定义上方

• 作用：标注当前方法作为异常后通知

• 格式：

  @AfterThrowing(value="pt()")
  public void afterThrowing(Throwable t){
  }
  

4.4.7)@Around

• 名称：@Around

• 类型：注解

• 位置：方法定义上方

• 作用：标注当前方法作为环绕通知

• 格式：

  @Around("pt()")
  public Object around(ProceedingJoinPoint pjp) throws Throwable {
      Object ret = pjp.proceed();
      return ret;
  }
  

• 特殊参数：

  • 无