AOP与IOC
Posted 码农新天地
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了AOP与IOC相关的知识，希望对你有一定的参考价值。
## AOP与IOC
> AOP(面向切面编程)与IOC（依赖注入）相信使用Spring的小伙伴都不会对这个陌生的，在Spring中，这两块可以说占据了Spring中的大半壁江山。也正因为如此，小编就简单的去讲解下这两方面。
## AOP
>AOP可以说是针对于OOP（面向对象编程）的一种加强。AOP从程序运行角度考虑程序的结构，提取业务处理过程的切面，OOP是静态的抽象，AOP是动态的抽象。AOP里面还采用代理模式。
接下来给大家展示下利用简单的代理模式AOP
### 接口示例
```java
package aopAndIoc.aop;
/**
* 接口
* @author Montos
*/
public interface IHello {
public void Hello(String message);
public void say(String message);
}
```
### 接口实现类示例
```java
package aopAndIoc.aop;
/**
* 实现类
* @author Montos
*/
public class HelloImpl implements IHello {
@Override
public void Hello(String message) {
System.out.println("输入的信息为：" + message + ",今天星期几");
}
@Override
public void say(String message) {
System.out.println("这是say的" + message + "的话语");
}
}
```
### 日志类示例
```java
package aopAndIoc.aop;
/**
* 日志类
* @author Montos
*/
public class Logger {
public static void loggerBefore() {
System.out.println("这是日志的前方法");
}
public static void loggerAfter() {
System.out.println("这是日志的后方法");
}
}
```
### 日志类示例
```java
package aopAndIoc.aop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 代理类
* @author Montos
*/
public class ProxyClass {
private IHello target;
public ProxyClass(IHello target) {
super();
this.target = target;
}
@SuppressWarnings("rawtypes")
public IHello getLoggerProxy() {
IHello hello = null;
// 代理对象由哪一个类加载器去加载
ClassLoader loader = target.getClass().getClassLoader();
// 代理对象的类型 即其中有哪些方法
Class[] interfaces = new Class[] { IHello.class };
InvocationHandler handler = new InvocationHandler() {
/**
* proxy：正在返回的那个代理类对象，一般情况下，在invoke中都不是用该对象
* method：被代理类的方法
* args：调用被代理类方法时，传入的参数
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String methodName = method.getName();
if (methodName.indexOf("Hello") != -1) {
Logger.loggerBefore();
method.invoke(target, args);
Logger.loggerAfter();
return "big";
} else {
method.invoke(target, args);
System.out.println("这里没有加强");
return "small";
}
}
};
hello = (IHello) Proxy.newProxyInstance(loader, interfaces, handler);
return hello;
}
}
```
### 测试类
```java
package aopAndIoc.aop;
public class Test {
public static void main(String[] args) {
IHello target = new HelloImpl();
IHello proxy = new ProxyClass(target).getLoggerProxy();
proxy.Hello("今天周六");
System.out.println("--------------------");
proxy.say("今天周日");
}
}
```
这下面就是运行成功的结果示意图：
## IOC
>IOC通常来说是依赖注入，其实可以分为依赖注入和控制反转。Spring中通过这个可以帮助我们引入我们所需要的对象，降低了组件之间的耦合度。Spring中的IOC实现依赖的是工厂模式+反射机制。
接下来给大家展示下利用简单的工厂模式实现的IOC
###接口类
```java
package aopAndIoc.ioc;
/**
* 水果类接口
* @author Montos
*/
public interface Fruit {
public void eat();
}
```
###接口实现类一
```java
package aopAndIoc.ioc;
/**
* 苹果类
* @author Montos
*/
public class Apple implements Fruit {
@Override
public void eat() {
System.out.println("苹果");
}
}
```
###接口实现类二
```java
package aopAndIoc.ioc;
/**
* 橙子类
* @author Montos
*/
public class Orange implements Fruit {
@Override
public void eat() {
System.out.println("橙子类");
}
}
```
###工厂类
```java
package aopAndIoc.ioc;
/**
* 工厂类
* @author Montos
*/
public class Factory {
public static Fruit getInstance(String className) {
Fruit fruit = null;
try {
fruit = (Fruit) Class.forName(className).newInstance();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return fruit;
}
}
```
###测试类
```java
package aopAndIoc.ioc;
/**
* 测试类
* @author Montos
*/
public class Test {
public static void main(String[] args) {
Fruit f = Factory.getInstance("aopAndIoc.ioc.Apple");
f.eat();
}
}
```
运行结果如下图
上面就简单的介绍了Spring中最为重要的两个方面，相信小伙伴们对这两块有了 一点的认识，之后我会给大家看看实际Spring中是如何实现这两个方面的。
以上是关于AOP与IOC的主要内容，如果未能解决你的问题，请参考以下文章