关于IOC与AOP的理解

1、IOC理论推导

1. UserDao接口

2. UserDaolmpl实现类

3. UserService业务接口

4. UserServicelmpl业务实现类

在之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改原代码！如果程序代码量十分大，修改一次的成本代价十分昂贵！

我们使用一个Set接口实现，已经发生了革命的变化

private UserDao userDao;

//利用set进行动态值的注入
public void setUserDao(UserDao userDao) {
    this.userDao = userDao;
}

● 之前，程序是主动创建对象!控制权在程序猿手上!
● 使用了set注入后，程序不再具有主动性,而是变成了被动的接受对象!

这种思想，从本质上解决了问题，我们程序猿不用再去管理对象的创建了。系统的耦合性大大降低~，可以更加专
注的在业务的实现上!这是IOC的原型!

1.1、IOC本质

控制反转IoC(Inversion of Control),是种设计思想， DI(依赖注入)是实现lOC的一 种方法，也
有人认为DI只是IoC的另一种说法。没有IoC的程序中,我们使用面向对象编程,对象的创建与对象间
的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三
方，个人认为所谓控制反转就是:获得依赖对象的方式反转了。

lOC是Spring框架的核心内容，使用多种方式完美的实现了IoC,可以使用XML配置，也可以使用注
解，新版本的Spring也可以零配置实现lOC。
Spring容器在初始化时先读取配置文件，根据配置文件或元数据创建与组织对象存入容器中，程序使
用时再从loc容器中取出需要的对象。

采用XML方式配置Bean的时候，Bean的定 义信息是和实现分离的，而采用注解的方式可以把两者合I
为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
**控制反转是一-种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式。在Spring中 **
实现控制反转的是lOC容器，其实现方法是依赖注入(Dependency lnjection,DI)。

1.2、HelloSpring(IOC实例)

Hello.java

package com.kuang.pojo;

public class Hello {

    private String str;

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    @Override
    public String toString() {
        return "Hello{" +
                "str='" + str + '\'' +
                '}';
    }
}

beans.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

<!--使用Spring来创建对象，在Spring这些都称为Bean

    类型  变量名 = new 类型();

    id = 变量名
    class = new 的对象
    property 相当于给属性赋值
        ref： 引用Spring容器中创建好的对象
        value 具体的值， 基本数据类型!

-->
    <bean id="hello" class="com.kuang.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>

</beans>

测试：

public class MyTest {
    public static void main(String[] args) {
        //获取Spring的上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //我们的对象现在都在Spring中的管理了，我们要使用，直接去里面取出来就可以!
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello);

    }

思考问题?

• Hello对象是谁创建的?

• hello对象是由Spring创建的

• Hello 对象的属性是怎么设置的?

• hello对象的属性是由Spring容器设置的，

这个过程就叫控制反转;

**控制:**谁来控制对象的创建,传统应用程序的对象是由程序本身控制创建的,使用Spring后,对象是

由Spring来创建的.

**反转:**程序本身不创建对象,而变成被动的接收对象.

**依赖注入:**就是利用set方法来进行注入的.

IOC是一种编程思想,由主动的编程变成被动的接收.

可以通过newClassPathXmlApplicationContext去浏览-下底层源码 .

OK,到了现在,我们彻底不用再程序中去改动了,要实现不同的操作,只需要在xmI配置文件中进行

修改,所谓的IOC,一句话搞定:对象由Spring来创建,管理,装配!

2、AOP

2.1、什么是AOP

AOP (Aspect Oriented Programming) 意为: 面向切面编程，通过预编译方式和运行期动态代理实现程序功能

的统一维 护 的一种技术。AOP是OOP的延续,是软件开发中的一个热点，也是Spring框架中的一一个重要内容，是

函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合

度降低，提高程序的可重用性,同时提高了开发的效率。

2.2、AOP在Spring中的作用

提供声明式事务：允许用户自定义切面

• 横切关注点:跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部

  分，就是横切关注点。如日志，安全,缓存,事务等等…

• 切面(ASPECT) :横切关注点被模块化的特殊对象。即，它是一个类。

• 通知(Advice) :切面必须要完成的工作。即，它是类中的一一个方法。

• 目标(Target) :被通知对象。

• 代理(Proxy) :向目标对象应用通知之后创建的对象。

• 切入点(PointCut) :切面通知执行的“地点”的定义。

• 连接点(JointPoint) :与切入点匹配的执行点。

SpringAOP中,通过Advice定义横切逻辑，Spring中支持5种类型的Advice:

即Aop在不改变原有代码的情况下,去增加新的功能

2.3、使用Spring实现AOP

【重点】使用AOP织入,需要导入一个依赖包!

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.5</version>
</dependency>

方式一：使用Spring的API接口

UserService.java

package com.kuang.service;

public interface UserService {

    public void add();

    public void delete();

    public void update();

    public void select();

}

UserServiceImpl.java

package com.kuang.service;

public class UserServiceImpl implements UserService{

    @Override
    public void add() {
        System.out.println("则增加数据");
    }

    @Override
    public void delete() {
        System.out.println("则删除数据");
    }

    @Override
    public void update() {
        System.out.println("修改数据");
    }

    @Override
    public void select() {
        System.out.println("则查询数据");
    }
}

BeforeLog.java

package com.kuang.log;

import org.springframework.aop.AfterReturningAdvice;

import java.lang.reflect.Method;

public class AfterLog implements AfterReturningAdvice {
    //returnValue   返回值
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("执行了"+method.getName()+"的方法，返回结果为"+returnValue);
    }
}

AfterLog.java

package com.kuang.log;

import org.springframework.aop.MethodBeforeAdvice;

import java.lang.reflect.Method;

public class BeforeLog implements MethodBeforeAdvice {
    //method    要执行目标对象的方法
    //args      参数
    //target    目标对象
    @Override
    public void before(Method method, Object[] args, Object target) throws Throwable {

        System.out.println("[DUGLOG]"+target.getClass().getName()+"的"+method.getName()+"别执行啦");
    }
}

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

    <!--注册类-->
    <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
    <bean id="beforeLog" class="com.kuang.log.BeforeLog"/>
    <bean id="afterLog" class="com.kuang.log.AfterLog"/>

    <!--方式一：使用原生Spring API-->
    <!--配置aop   需要导入aop约束-->
    <aop:config>
        <!--切入点 expression表达式execution(要执行的位置! * * * * *)表达式-->
        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
        
        <!--执行环绕增加-->
        <aop:advisor advice-ref="beforeLog" pointcut-ref="pointcut"/>
        <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
        
    </aop:config>


</beans>

测试：

import com.kuang.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {

    @Test
    public void Test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //动态代理的是接口:注意点
        UserService userService = (UserService) context.getBean("userService");
        userService.add();
    }
}

方式二：自定义来实现AOP 【建议】

DiyPointCut.java

package com.kuang.DIY;

public class DiyPointCut {

    public void before(){
        System.out.println("===============方法执行前===========");
    }

    public void after(){
        System.out.println("===============方法执行后===========");
    }
}

<!--方式二：自定义类-->
<bean id="diy" class="com.kuang.DIY.DiyPointCut"/>
<aop:config>
    <!--自定义切面 ref要引用的类-->
    <aop:aspect ref="diy">
        <!--切入点-->
        <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
        <!--通知-->
        <aop:before method="before" pointcut-ref="pointcut"/>
        <aop:after method="after" pointcut-ref="pointcut"/>
    </aop:aspect>
</aop:config>

测试:

@Test
public void Test(){
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    //动态代理的是接口:注意点
    UserService userService = (UserService) context.getBean("userService");
    userService.add();
}

方式三：使用注解实现：【了解】

package com.kuang.DIY;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;


//方式三：使用注解实现AOP
//标注这个类是一个切面
@Aspect
public class AnnotationPointCut {

    @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("===============方法执行前===========");
    }

    @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("===============方法执行后===========");
    }

    @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {

        System.out.println("环绕前");
        Object proceed = jp.proceed();
        System.out.println("环绕后");

    }



}

<!--方式三：使用注解实现AOP-->
<bean id="annotationPointCut" class="com.kuang.DIY.AnnotationPointCut"/>
<!--开启注解支持-->
<aop:aspectj-autoproxy/>

注意点：别导错包