spring IOC(DI)和AOP

IOC（Inversion of Control，控制倒转）Ioc意味着将你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。

DI—Dependency Injection，即“依赖注入”：组件之间依赖关系由容器在运行期决定，形象的说，即由容器动态的将某个依赖关系注入到组件之中。

依赖注入(DI)和控制反转(IOC)是从不同的角度的描述的同一件事情，就是指通过引入IOC容器，利用依赖关系注入的方式，实现对象之间的解耦。

AOP: Aspect-OrientedProgramming（面向切面编程）。AOP适合于那些具有横切逻辑的应用：如性能监测，访问控制，事务管理、缓存、对象池管理以及日志记录。AOP将这些分散在各个业务逻辑中的代码通过横向切割的方式抽取到一个独立的模块中。AOP 实现的关键就在于 AOP 框架自动创建的 AOP 代理，AOP 代理则可分为静态代理和动态代理两大类，其中静态代理是指使用 AOP 框架提供的命令进行编译，从而在编译阶段就可生成 AOP 代理类，因此也称为编译时增强；而动态代理则在运行时借助于 JDK 动态代理、CGLIB 等在内存中“临时”生成 AOP 动态代理类，因此也被称为运行时增强。

IOC例子:

package cqvie.com;
interface USB //USB接口
{
  public void insert();
  public String read();
  public void write(String s);
  public void pop();
}

USB.java

package cqvie.com;
import org.springframework.stereotype.Component;
@Component
public class UDisk implements USB
{
  public void insert() {
      System.out.println("读入U盘");
      }
  public String read(){
      System.out.println("读取数据:");
      return "data";
  }
  public void write(String s){
      System.out.println("写入数据");
  }
  public void pop(){
      System.out.println("弹出U盘");
  }
}

UDisk.java

package cqvie.com;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
@Component("theComputer")
public class Computer
{
  @Autowired
  //@Qualifier("UDisk")
  private USB usbDevice;
  public Computer(){ }  //这里不能构造USB设备
  public void saveData(String data) //实现智能设备的方法
  { //insert,write,pop
      usbDevice.insert();
      usbDevice.write(data);
      usbDevice.pop();
  }
  public void setUsbDevice(USB u){  usbDevice=u;  }
}

Computer.java

package cqvie.com;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class test {
    public static void main(String[] args) {
          //Computer c=new Computer();
          //USB u=new UDisk();
          //c.setUsbDevice(u);
         ApplicationContext ctx = new ClassPathXmlApplicationContext(
                "applicationContext.xml");
             Computer c=(Computer) ctx.getBean("theComputer");
             c.saveData("个人简历"); 

           Computer1 c1=new Computer1();
              HDD mp=new movHDD();
              c1.setMpDevice(mp);
              c1.saveData("移动硬盘");
    }
}

test.java

<?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"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
    <bean id="u1" class="cqvie.com.UDisk"></bean>
    <bean id="theComputer" class="cqvie.com.Computer">
        <property name="usbDevice" ref="u1"></property>
    </bean>
</beans>

applicationContext.xml

运行结果如下:

AOP例子:

package org.proxy.interfaces;
//老板接口
public interface ILaoBan {
    public void kaiHui();
}

package org.proxy.interfaces.impl;

import org.proxy.interfaces.ILaoBan;

//接口实现类
public class LaoBan implements ILaoBan{

    @Override
    public void kaiHui() {
       System.out.println("--->老板要开会");
    }
}

LaoBan

package org.proxy.proxyClass;
import org.proxy.interfaces.ILaoBan;

public class MiShu implements ILaoBan{

    private ILaoBan laoban;
    public MiShu(ILaoBan laoban){
        this.laoban = laoban;
    }

    private void before() {
        System.out.println("订机票");
        System.out.println("订酒店");
        System.out.println("送老板");
    }

    private void after() {
        System.out.println("订机票");
        System.out.println("退酒店");
        System.out.println("接老板");
    }

    @Override
    public void kaiHui() {
         before();
         laoban.kaiHui();
         after();
    }

}

MiShu

package test;

import org.proxy.interfaces.ILaoBan;
import org.proxy.interfaces.impl.LaoBan;
import org.proxy.proxyClass.MiShu;

public class Test {
    public static void main(String args[]){
        ILaoBan proxy_laoban = new MiShu(new LaoBan());
        proxy_laoban.kaiHui();
    }
}

运行结果如下：

--------动态代理

package org.proxy.interfaces;
//老板接口
public interface IBoss {
    public void kaiHui();  //老板要开会
}

IBoss.java

package org.proxy.interfaces.impl;

import org.proxy.interfaces.IBoss;

//接口实现类
public class Boss implements IBoss{

    public void kaiHui()
    {
      System.out.println("老板要开会");
    }
}

Boss.java

package org.proxy.proxyClass;
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("订机票,退酒店,接老板");
    }
}

DynamicProxy.java

package test;
import org.proxy.interfaces.IBoss;
import org.proxy.interfaces.impl.Boss;
import org.proxy.proxyClass.DynamicProxy;

public class Test {
    public static void main(String args[]){
        DynamicProxy proxy=new DynamicProxy();
        IBoss boss=(IBoss) proxy.bind(new Boss());
        boss.kaiHui();
    }
}

Test.java

运行结果如下: