IOC和AOP的简单实现

一直使用spring，说起来就是IOC和AOP，看过不少原理的书，但是spring的代码太多，梳理起来很困难，于是想自己实现一下，昨天下午写出代码来，分享一下。

目标：

1、使用annotation编程进行分层，有service层和dao层（mapper层）。

2、设置容器，将所有的实例注入到容器里，类似spring的applicationContext。

3、dao层使用接口，没有实现类，类似于ibitas的使用方式。

4、读取本地文件内容。

根据目标大概思考并实践了以下几点:

1、动态代理选用cglib实现，首先这是spring的实现方式，其次亲测使用jdk的反射包无法实现对接口的动态代理，无法满足上述目标3。

2、容器使用单例模式创建，保证所有的bean只有一个。

代码如下:

首先是自定义的Annotation，为了和spring的加以区别，我都加上了Fx前缀。

第一个是FxMapper，类似spring的@Repository，也就是Dao层应该加的Annotation

package com.smikevon.proxy.annotations;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
* Created by fengxiao on 15-1-27.
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FxMapper {
String value();
}

第二个是FxService对应于spring的service层，类似spring的@Service。

package com.smikevon.proxy.annotations;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
* Created by fengxiao on 15-1-27.
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface FxService {
String value();
}

第三个FxResource对应spring里的@Resource，也就是类内饮用的注释

package com.smikevon.proxy.annotations;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
* Created by fengxiao on 15-1-27.
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface FxResource {
String value();
}

Annotation类全部贴完，下面贴出各层的一个示例类。

按上面顺序，第一个mapper类

package com.smikevon.proxy.dynamic;

import com.smikevon.proxy.annotations.FxMapper;
/**
* Created by fengxiao on 15-1-27.
*/
@FxMapper("fileMapper")
public interface FileMapper {
public String read(String fileDir);
public void append(String fileDir , String message);
}

第二个service类

package com.smikevon.proxy.dynamic;

import com.smikevon.proxy.annotations.FxResource;
import com.smikevon.proxy.annotations.FxService;

/**
* Created by fengxiao on 15-1-27.
*/
@FxService("fileService")
public class FileService {
String file = "rFile.txt";

@FxResource(value="fileMapper")
public FileMapper fileMapper;

public void read(){
System.out.println("hello world");
String txt = fileMapper.read(file);
System.out.println("message:"+txt);
}
}

示例类已经贴完，下面贴出容器类。容器类通过使用一个hashmap来实现容器，这里没有考虑线程安全的问题，只是为了示例。初始化使用静态内部类来实现单例模式。

package com.smikevon.proxy.dynamic;

import com.smikevon.proxy.Processors.FileMapperProcessor;
import com.smikevon.proxy.Processors.FileServiceProcessor;
import com.smikevon.proxy.annotations.FxMapper;
import com.smikevon.proxy.annotations.FxService;

import java.io.File;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

/**
* Created by fengxiao on 15-1-27.
*/
public class FxApplicationContext {

private static final String JAVA_SOURCE_DIR = "src/main/java";
private static final String JAVA_PACKAGE_DIR = "com/smikevon/proxy/dynamic";
private static final String JAVA_PACKAGE_PATH = "com.smikevon.proxy.dynamic";

private Map<String,Object> context = new HashMap<String,Object>();

private FxApplicationContext(){}

/**
* 容器初始化
*/
public FxApplicationContext init(){
try {
File file1 = new File(JAVA_SOURCE_DIR+File.separator+JAVA_PACKAGE_DIR);
File[] files = file1.listFiles();
for(File file : files){
if(file.getName().endsWith("java")){
String name = file.getName().substring(0,file.getName().indexOf("."));
Class<?> clazz = Class.forName(JAVA_PACKAGE_PATH+"."+name);
if(clazz.getAnnotation(FxMapper.class)!=null){
String key = clazz.getAnnotation(FxMapper.class).value();
//实例化mapper的处理类
FileMapperProcessor processor = new FileMapperProcessor();
if(context.get(key) == null){
context.put(key,processor.bind(clazz));
}
}
if(clazz.getAnnotation(FxService.class)!=null){
String key = clazz.getAnnotation(FxService.class).value();
//实例化service的处理类
FileServiceProcessor processor = new FileServiceProcessor();
if(context.get(key) == null){
context.put(key,processor.bind(clazz));
}
}
}
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
return this;

}

public Object getBean(String beanId){
Iterator<Map.Entry<String, Object>> iterator = context.entrySet().iterator();
while(iterator.hasNext()){
Map.Entry<String, Object> entry = iterator.next();
String key = entry.getKey();
if(key.equals(beanId)){
return entry.getValue();
}
}
return null;
}

/**
* 静态内部类方式实现单例
*/
private static class FxApplicationContextHolder{
public static FxApplicationContext instance = new FxApplicationContext();
}

public static FxApplicationContext getInstance(){
return FxApplicationContextHolder.instance;
}

}

动态代理引用了cglib包，在项目里要加上如下引用：

<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>

代理类如下：

先是对有@FxMapper标记的类的动态代理方法

package com.smikevon.proxy.Processors;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.lang.reflect.Method;

/**
* Created by fengxiao on 15-1-27.
*/
public class FileMapperProcessor implements MethodInterceptor{

public Object bind(Class clazz) {
Enhancer enhancer = new Enhancer();
enhancer.setCallback(this);
enhancer.setSuperclass(clazz);
Object obj = enhancer.create();
return obj;
}

@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
StringBuilder sb = new StringBuilder();
if(method.getName().toLowerCase().startsWith("read")){
if (objects.length > 0) {
String fileDir = (String) objects[0];
File file = new File(fileDir);
BufferedReader br = new BufferedReader(new FileReader(file));

String line = null;
while((line = br.readLine())!=null){
sb.append(line);
}
}
}
return sb.toString();
}
}

其次是对有@FxService标记的类的动态代理方法

package com.smikevon.proxy.Processors;

import com.smikevon.proxy.annotations.FxResource;
import com.smikevon.proxy.dynamic.FxApplicationContext;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

/**
* Created by fengxiao on 15-1-27.
*/
public class FileServiceProcessor implements MethodInterceptor{

private Object target;

public Object bind(Class clazz) {
try {
target = clazz.newInstance();

Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
Object obj = enhancer.create();

//将mapper的实例bean赋值给对应的引用
Field[] fields = clazz.getDeclaredFields();
for(Field field : fields){
if (field.getAnnotation(FxResource.class)!=null){
String value = field.getAnnotation(FxResource.class).value();
Object object = FxApplicationContext.getInstance().getBean(value);
//看到没下面这行代码和注释掉的代码效果是一样的,反射的强大之处
field.set(target,object);
//((FileService)target).fileMapper = (FileMapper)object;
}
}
return obj;
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
return null;
}

@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
method.invoke(target,objects);
return null;
}
}

其实，@FxService和@FxMapper可以合并成一个Annotation，对应的动态代理类也可以合并为一个（类似Spring的@Component ），但是那样的话，每个类的处理逻辑就会比较复杂，不易理解。

下面是测试方法类:

package com.smikevon.proxy.dynamic;

import java.lang.reflect.InvocationTargetException;

/**
* Created by fengxiao on 15-1-27.
*/
public class FileDemo {

public static void main(String[] args) throws InvocationTargetException {
FxApplicationContext fxApplicationContext = FxApplicationContext.getInstance().init();
FileService fileService = (FileService)fxApplicationContext.getBean("fileService");
fileService.read();
}

}

我的文件内容（文件名fFile.txt,位置就在项目根目录）：

hello , my name is Mr Read!

I love reading books!

输出结果：

hello world
message:hello , my name is Mr Read!I love reading books!

看下有没有很熟悉，和spring使用bean的方式是不是很一致? 原理原来没有什么神秘的，就是这么简单。

这里那里用到了IOC？

容器方式初始化bean，将bean的生命周期交付给容器（hashmap），而不是调用者，示例里容器的生命周期比较简单，即调用init()方法后开始，程序执行完成结束。

这里那里用到了AOP？

通过动态代理读取接口参数，获取相应文件内容，这就是aop。