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 }