IOC控制反转和AOP切面思想

有问题别喷我啊~我只是个学生罢了

1.IOC控制反转

1.1 原理

控制反转是Spring框架的核心。其原理是基于面向对象(OO)设计原则的The Hollywood Principle：Don’t call us, we’ll call you（别找我，我会来找你的）。也就是说，所有的组件都是被动的，所有的组件初始化和调用都由容器负责。组件处在一个容器当中，由容器负责管理。简单的来讲，就是由容器控制程序之间的关系，而非传统实现中，由程序代码直接操控，即在一个类中调用另外一个类。这也就是所谓“控制反转”的概念所在：控制权由应用代码中转到了外部容器，控制权的转移，即所谓反转。

1.2 区别

在传统的Java SE开发中，往往需要在程序内部通过new关键字来创建需要的对象，这种控制权在程序猿的手上，

随着项目的增大，每次这种创建对象的方式都需要进行在写好的源码上改动，对维护来说都是不方便和安全的。

但是，在IOC中有专门的容器来创建这些对象，就是把控制权交给IOC，而不是程序猿本身。

1.3 IOC能干嘛

IOC的关键目的就是降低代码的耦合度，就是“松耦合”。

对象集中管理。

1.4 依赖注入

什么是依赖注入？ DI注入其实可以说是IOC的一种实现方式

相当于A要操作数据库，之前我们是要自己创建一个JdbcUtils类来获取Connection对象，有了IOC后，就可以直接告诉spring，我们在某个类中要使用Connection 对象。在程序运行中spring就会创建一个Connection对象，注入到这个类中。

简单来说就是A需要依赖Connection才能正常运行，spring是将Connection注入到A中的，这就是依赖注入。

2.IOC实现原理

2.1底层原理

• xml解析
• 工厂设计模式
• 反射

3.AOP底层原理

1. Aop底层实现动态代理

   • 有两种情况的动态代理

     • 有接口，使用JDK静态代理

       创建接口实现类的代理对象，增强类的方法

     • 没有接口 ，使用cglib动态代理

       创建当前类的子类对象，增强类的方法

2. 代码实现

   • 使用JDK动态代理 实现 Proxy

   • 1. 创建接口，定义方法
     -----------------------------------------------------------------------
     package com.study.AOP.Interface;
     
     public interface UserDao {
     
         public int add(int a ,int b);
     
         public String update(String id);
     }
     ---------------------------------------------------------------------------
     2.继承接口、实现方法
     ---------------------------------------------------------------------------
         package com.study.AOP;
     
     import com.study.AOP.Interface.UserDao;
     
     public class UserDaoImpl implements UserDao {
         public int add(int a, int b) {
             return a + b;
         }
     
         public String update(String id) {
             return id;
         }
     }
     ---------------------------------------------------------------------------
     3.使用Proxy创建代理对象
     public class JDKProxy {
     
         public static void main(String[] args) {
             Class[] interfaces = {UserDao.class};
             UserDaoImpl userDaoImpl= new UserDaoImpl();
             UserDao userDao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDaoImpl));
             int result = userDao.add(1, 2);
             System.out.println("result"+result);
         }
     }
     //创建代理对象
     class  UserDaoProxy implements InvocationHandler{
     
     
         //传入代理对象
         //有参构造传递
         private Object object;
         public UserDaoProxy(Object obj){
             this.object = obj;
         }
         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     
             //增强逻辑 add()  update()
             //方法之前
             System.out.println("方法之前执行"+method.getName());
             Object res = method.invoke(object, args);
             //方法之后
             System.out.println("方法之后执行"+object);
             return res;
         }
     }
     -----------------------------------------------------------------------
         
     

3. Aop术语

   连接点

   类里的某些方法被增强了，叫做连接点。

   切入点

   实际被增强的方法，称为切入点。

   通知（增强）

   实际增强的逻辑部分称通知。

   通知的多种类型

   • 前置通知
   • 后置通知
   • 环绕通知
   • 异常通知
   • 最终通知

   切面 （动作）

   把通知应用到切入点的过程

4. Aop操作(准备)

   Spring 基于AspectJ实现AOP

   AspectJ是一个单独框架

   • 基于xml配置文件
   • 基于注解方式实现

5. 切入点表达式

   语法结构

   execution( 权限修饰符 类全路径 [参数列表])

6. 代码实现

   • 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:context="http://www.springframework.org/schema/context"
          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/context
           https://www.springframework.org/schema/context/spring-context.xsd
           http://www.springframework.org/schema/aop
           https://www.springframework.org/schema/aop/spring-aop.xsd">
   
       <context:component-scan base-package="com.study.AOP.AopAnnotation">
   
       </context:component-scan>
   
       <aop:aspectj-autoproxy>
   
       </aop:aspectj-autoproxy>
   </beans>
   

   • User类

   package com.study.AOP.AopAnnotation;
   
   
   import org.aspectj.lang.annotation.Aspect;
   import org.aspectj.lang.annotation.Before;
   import org.springframework.stereotype.Component;
   
   @Component
   public class User {
   
       public void add(){
           System.out.println("add().......);
       }
   }
   
   

   • UserProxy类

   //增强类
   @Component
   @Aspect //生成代理对象
   public class UserProxy {
   
   
       //前置通知
       @Before(value = "execution(* com.study.AOP.AopAnnotation.User.add(..))")
       public void Before(){
           System.out.println("Before.....");
       }
   
   }
   
   //通知配置
   //1.开启注解扫描  2.使用注解创建注解User和UserProxy  3.增强类上添加注解@Aspect 4.在spring中开启生成代理对象