Spring IOC(DI)和AOP学习笔记

时间 2019-11-12

标签 spring ioc aop 学习笔记栏目 Spring 繁體版

原文原文链接

软件152 缑旭浩java

首先概念阐述以下：spring

IOC: Inversion of Control(控制反转)是一种设计思想，就是容器控制应用程序所须要外部资源的建立和管理，而后将其反转给应用程序。对象及其依赖对象的建立及维护都不须要在应用程序中实现，将其交给IOC容器去管理。传统的开发中，咱们本身在对象内部建立依赖对象并注入当前对象，完成依赖关系的维护；对于IOC而言，它强调是将主动变为被动，由IOC容器来负责依赖对象的建立和查找，由IOC容器来进行注入组合对象，咱们只须要在相关的配置文件中维护对象之间的依赖关系便可。编程

DI: Dependency Injection，即“依赖注入”。其实IOC和DI本就是同一个概念的两种不一样的表述，应用程序依赖容器提供的外部对象，容器将其依赖的外部资源在运行期注入到应用程序中；某个对象被调用时，其所依赖的对象由容器注入。app

AOP是OOP的延续，是（Aspect Oriented Programming）的缩写，意思是面向切面编程。要理解AOP首先得弄明白代理的概念。AOP利用一种称为“横切”的技术，剖解开封装的对象内部，将那些影响多个类的公共行为封装到一个可重用模块，并将其名为方面(Aspect)。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑封装起来的部分。以便于减小系统的重复代码，下降模块间的耦合度，并有利于系统维护。框架

使用“横切”技术，AOP把软件系统分为两个部分：核心关注点（业务逻辑）和横切关注点（通用逻辑，即方面）。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的特色是，其常常发生在核心关注点的多处，而各处都基本类似。好比权限认证、日志、事务处理，debug管理，性能检测等。AOP 的做用在于分离系统中的各类关注点，将核心关注点和横切关注点分离开来。AOP将这些分散在各个业务逻辑中的代码经过横向切割的方式抽取到一个独立的模块中。AOP 实现的关键就在于 AOP 框架自动建立的 AOP 代理，AOP 代理则可分为静态代理和动态代理两大类，其中静态代理是指使用 AOP 框架提供的命令进行编译，从而在编译阶段就可生成 AOP 代理类，所以也称为编译时加强；而动态代理则在运行时借助于 JDK 动态代理、CGLIB 等在内存中“临时”生成 AOP 动态代理类，所以也被称为运行时加强。ide

IOC例子以下：性能

1 package cqvie.com;
2 interface USB //USB接口
3 {
4   public void insert();
5   public String read();
6   public void write(String s);
7   public void pop();
8 }

 1 package cqvie.com;
 2 import org.springframework.stereotype.Component;
 3 @Component
 4 public class UDisk implements USB
 5 {
 6   public void insert() {
 7       System.out.println("读入U盘");
 8       }
 9   public String read(){
10       System.out.println("读取数据:"); 
11       return "data";
12   }
13   public void write(String s){
14       System.out.println("写入数据");
15   }
16   public void pop(){
17       System.out.println("弹出U盘");
18   }
19 }

 1 package cqvie.com;
 2 import org.springframework.beans.factory.annotation.Autowired;
 3 import org.springframework.beans.factory.annotation.Qualifier;
 4 import org.springframework.stereotype.Component;
 5 @Component("theComputer")
 6 public class Computer
 7 {
 8   @Autowired
 9   //@Qualifier("UDisk")
10   private USB usbDevice;
11   public Computer(){ }  //这里不能构造USB设备
12   public void saveData(String data) //实现智能设备的方法
13   { //insert,write,pop
14       usbDevice.insert();
15       usbDevice.write(data);
16       usbDevice.pop();
17   }
18   public void setUsbDevice(USB u){  usbDevice=u;  }   
19 }

 1 package cqvie.com;
 2 import org.springframework.context.ApplicationContext;
 3 import org.springframework.context.support.ClassPathXmlApplicationContext;
 4 public class test {
 5     public static void main(String[] args) {
 6           //Computer c=new Computer();
 7           //USB u=new UDisk();
 8           //c.setUsbDevice(u);
 9          ApplicationContext ctx = new ClassPathXmlApplicationContext(
10                 "applicationContext.xml");
11              Computer c=(Computer) ctx.getBean("theComputer");
12              c.saveData("我的简历"); 
13              
14            Computer1 c1=new Computer1();
15               HDD mp=new movHDD();
16               c1.setMpDevice(mp);
17               c1.saveData("移动硬盘");             
18     }
19 }

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans
 3     xmlns="http://www.springframework.org/schema/beans"
 4     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5     xmlns:p="http://www.springframework.org/schema/p"
 6     xmlns:context="http://www.springframework.org/schema/context"
 7     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
 8     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
 9     <bean id="u1" class="cqvie.com.UDisk"></bean>
10     <bean id="theComputer" class="cqvie.com.Computer">
11         <property name="usbDevice" ref="u1"></property>
12     </bean>
13 </beans>

相应的运行结果如图：ui

APO例子以下：this

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

 1 package org.proxy.interfaces.impl;
 2 
 3 import org.proxy.interfaces.ILaoBan;
 4 
 5 //接口实现类
 6 public class LaoBan implements ILaoBan{
 7 
 8     @Override
 9     public void kaiHui() {
10        System.out.println("--->老板要开会");
11     }
12 }

 1 package org.proxy.proxyClass;
 2 import org.proxy.interfaces.ILaoBan;
 3 
 4 public class MiShu implements ILaoBan{
 5 
 6     private ILaoBan laoban;
 7     public MiShu(ILaoBan laoban){
 8         this.laoban = laoban;
 9     }
10 
11     private void before() {    
12         System.out.println("订机票");
13         System.out.println("订酒店");
14         System.out.println("送老板");
15     }
16     
17     private void after() {
18         System.out.println("订机票");
19         System.out.println("退酒店");
20         System.out.println("接老板");
21     }
22     
23     @Override
24     public void kaiHui() {
25          before();
26          laoban.kaiHui();
27          after();
28     } 
29 }

 1 package test;
 2 
 3 import org.proxy.interfaces.ILaoBan;
 4 import org.proxy.interfaces.impl.LaoBan;
 5 import org.proxy.proxyClass.MiShu;
 6 
 7 public class Test {
 8     public static void main(String args[]){
 9         ILaoBan proxy_laoban = new MiShu(new LaoBan());
10         proxy_laoban.kaiHui();
11     }
12 }

相应运行结果如图：spa

动态代理例子：

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

 1 package org.proxy.interfaces.impl;
 2 
 3 import org.proxy.interfaces.IBoss;
 4 
 5 //接口实现类
 6 public class Boss implements IBoss{
 7 
 8     public void kaiHui()
 9     {
10       System.out.println("老板要开会");
11     }
12 }

 1 package org.proxy.proxyClass;
 2 import java.lang.reflect.InvocationHandler;
 3 import java.lang.reflect.Method;
 4 import java.lang.reflect.Proxy;
 5 
 6 //动态代理类
 7 public class DynamicProxy implements InvocationHandler{
 8     private Object obj;
 9     public Object bind(Object obj){
10         this.obj=obj;
11         return Proxy.newProxyInstance(obj.getClass().getClassLoader(), 
12                 obj.getClass().getInterfaces(), this);
13     }
14     public Object invoke(Object proxy, Method method, Object[] objs)
15             throws Throwable {
16         Object result=null;
17         try{
18             before();
19             result=method.invoke(obj, objs);
20             after();
21         }catch(Exception e){
22             e.printStackTrace();
23         }
24         return result;
25     }
26     public void before(){
27         System.out.println("订机票,订酒店,送老板");
28         }
29     
30     public void after(){
31         System.out.println("订机票,退酒店,接老板");
32     }
33 }

 1 package test;
 2 import org.proxy.interfaces.IBoss;
 3 import org.proxy.interfaces.impl.Boss;
 4 import org.proxy.proxyClass.DynamicProxy;
 5 
 6 
 7 public class Test {
 8     public static void main(String args[]){
 9         DynamicProxy proxy=new DynamicProxy();
10         IBoss boss=(IBoss) proxy.bind(new Boss());
11         boss.kaiHui();
12     }
13 }

运行结果以下图: