spring IOC(DI)和AOP实验

spring IOC (DI)实验

(1)什么是DI
依赖注入（Dependecy Injection）和控制反转（Inversion of Control）是同一个概念，具体的讲：当某个角色需要另外一个角色协助的时候，在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在spring中创建被调用者的工作不再由调用者来完成，因此称为控制反转。创建被调用者的工作由spring来完成，然后注入调用者因此也称为依赖注。spring以动态灵活的方式来管理对象 ， 注入的两种方式，设置注入和构造注入。
设置注入的优点：直观，自然
构造注入的优点：可以在构造器中决定依赖关系的顺序
(2)DI实例

 

interface Word{
    String spell(String x,String y);
}

public class SpringDISample{
    
    Word word;
   
    public void setWord(Word word) {
        this.word = word;
    }
    public void say (){
        System.out.println("before");
        System.out.println(word.spell("小明", "小熊"));
        System.out.println("after");
    }
}
/
class ImpWord1 implements Word{
    @Override
    public String spell(String x, String y) {
        return x + "的朋友是" + y;
    }
}
class ImpWord2 implements Word{
    @Override
    public String spell(String x, String y) {
        return x + "的同事是" + y;
    }
}
/**
 *  相当于springDI的容器。
 */
class Main {
    // 容器启动
    public static void main(String[] args) {
        // 创建DI容器
        SpringDISample springDISample = new SpringDISample();
        // new出Word的实现类ImpWord1，并注入到springDISample的say方法里。
        springDISample.setWord(new ImpWord1());
        springDISample.say();
        System.out.println("***************************************");
        // new出Word的实现类ImpWord2，并注入到springDISample的say方法里。
        springDISample.setWord(new ImpWord2());
        springDISample.say();
    }
}

 spring AOP 实验

AOP核心概念

1、横切关注点

对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点

2、切面（aspect）

类是对物体特征的抽象，切面就是对横切关注点的抽象

3、连接点（joinpoint）

被拦截到的点，因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器

4、切入点（pointcut）

对连接点进行拦截的定义

5、通知（advice）

所谓通知指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类

6、目标对象

代理的目标对象

7、织入（weave）

将切面应用到目标对象并导致代理对象创建的过程

8、引入（introduction）

 

基于Spring的AOP简单实现

 

1.DynamicProxy.java

package test;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

public class DynamicProxy implements InvocationHandler{

       private Object obj;

       public Object bind(Object obj){

              this.obj=obj;

              return Proxy.newProxyInstance(obj.getClass().getClassLoader(),

                            obj.getClass().getInterfaces(), this);

       }

       public Object invoke(Object proxy, Method method, Object[] objs)

                     throws Throwable {

              Object result=null;

              try{

                     before();

                     result=method.invoke(obj, objs);

                     after();

              }catch(Exception e){

                     e.printStackTrace();

              }

              return result;

       }

       public void before(){

              System.out.println("执行之前做一些事情...");

              }

       public void after(){

              System.out.println("执行之后做一些事情...");

              }

}

2.创建test.java 测试结果

package test;

public class Test {

       public static void main(String args[]){

              DynamicProxy proxy=new DynamicProxy();

              IBoss boss=(IBoss) proxy.bind(new Boss());

              boss.meeting();

       }}

 

转载于:https://www.cnblogs.com/Sike/p/7086732.html