软件152 缑旭浩
首先概念阐述如下：
IOC: Inversion of Control(控制反转)是一种设计思想，就是容器控制应用程序所需要外部资源的创建和管理，然后将其反转给应用程序。对象及其依赖对象的创建及维护都不需要在应用程序中实现，将其交给IOC容器去管理。传统的开发中，我们自己在对象内部创建依赖对象并注入当前对象，完成依赖关系的维护；对于IOC而言，它强调是将主动变为被动，由IOC容器来负责依赖对象的创建和查找，由IOC容器来进行注入组合对象，我们只需要在相关的配置文件中维护对象之间的依赖关系即可。
DI: Dependency Injection，即“依赖注入”。其实IOC和DI本就是同一个概念的两种不同的表述，应用程序依赖容器提供的外部对象，容器将其依赖的外部资源在运行期注入到应用程序中；某个对象被调用时，其所依赖的对象由容器注入。
AOP是OOP的延续，是（Aspect Oriented Programming）的缩写，意思是面向切面编程。要理解AOP首先得弄明白代理的概念。AOP利用一种称为“横切”的技术，剖解开封装的对象内部，将那些影响多个类的公共行为封装到一个可重用模块，并将其名为方面(Aspect)。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑封装起来的部分。以便于减少系统的重复代码，降低模块间的耦合度，并有利于系统维护。
使用“横切”技术，AOP把软件系统分为两个部分：核心关注点（业务逻辑）和横切关注点（通用逻辑，即方面）。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的特点是，其经常发生在核心关注点的多处，而各处都基本相似。比如权限认证、日志、事务处理，debug管理，性能检测等。AOP 的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。AOP将这些分散在各个业务逻辑中的代码通过横向切割的方式抽取到一个独立的模块中。AOP 实现的关键就在于 AOP 框架自动创建的 AOP 代理，AOP 代理则可分为静态代理和动态代理两大类，其中静态代理是指使用 AOP 框架提供的命令进行编译，从而在编译阶段就可生成 AOP 代理类，因此也称为编译时增强；而动态代理则在运行时借助于 JDK 动态代理、CGLIB 等在内存中“临时”生成 AOP 动态代理类，因此也被称为运行时增强。
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>
相应的运行结果如图：
APO例子如下：
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 }
相应运行结果如图：
动态代理例子：
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 }
运行结果如下图:
来源：https://www.cnblogs.com/javaeeadd/p/7106448.html