依赖注入，控制反转，面向切片的运用！

本工程使用.properties文件来配置文件

1. forName
使用Class类的forName()静态方法。该方法传入字符串参数，该字符串参数的值是某个类的全限类名

（必须添加完整包名）。

2.实例化Class对象
方法一、使用Class对象的newInstance（）方法来创建Class对象对应类的实例，这种方法要求该

Class对象的对应类有默认构造器，而执行newInstance（）方法时实际上是利用默认构造器来创建类

的实例。
方法二、利用指定构造器来创建java对象
（1）、获取该类的Class对象。
（2）、利用Class对象的getConstructor（）方法来获取指定构造器
（3）、调用Constructor的newInstance（）方法来创建Java对象。

3、调用方法

获得某个对应的Class对象后，就可以调用对象的getMethods（）方法或者getMethod（）方法来获取全部方法或指定方法-----这两个方法的返回值是Method对象数组，或者Method对象。每个Method里包含一个invoke方法。

1.定义个逻辑接口

package com.logic;

public interface ILogic {
int add(int min,int max);
}

2.实现逻辑接口

package com.logic;

public class MyLogic implements ILogic {

public int add(int min, int max) {

return min+max;
}

}

3.定义一个附加功能接口类

package com.semi;

public interface ISemi {
void print();
}

4.实现一个附加类接口

package com.semi;

public class MySemi implements ISemi {

public void print() {
System.out.println("MySemi is printed!");

}

}

5.定义一个动态代理接口

package com.proxy;

import com.logic.ILogic;

public interface IProxy {
ILogic GetProxyInstance();
}

6.实现动态代理接口类

package com.proxy;
import com.logic.ILogic;
import com.semi.ISemi;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class MyProxyFactory implements IProxy,InvocationHandler {
private ILogic logic;
private ISemi  semi;
public ILogic getLogic() {
return logic;
}
public void setLogic(ILogic logic) {
this.logic = logic;
}
public ISemi getSemi() {
return semi;
}
public void setSemi(ISemi semi) {
this.semi = semi;
}
//函数回调
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
semi.print();
return method.invoke(logic,args);
}
//实例化对象
public ILogic GetProxyInstance()
{
ILogic res=(ILogic)Proxy.newProxyInstance(logic.getClass().getClassLoader(),
logic.getClass().getInterfaces(), this);
return res;
}
}

7.使用反射技术，依赖注入来调用业务类

package com.toolkit;
import java.io.*;
import java.lang.reflect.Method;
import java.util.Properties;
import com.logic.ILogic;
import com.semi.ISemi;
public class MySpring {
Properties prop;
String filename;
String logic_classname;
String semic_lassname;
String proxyfacotory_classname;
public MySpring(String filename)
{
this.filename=filename;
prop=new Properties();
ReadProperties();
}
public Object GetPorxyFactory()
{
Object proxyfacotory=null;
try{

Object logic=null;
Object semi=null;

Class type=Class.forName(logic_classname);
logic=type.newInstance();

type=Class.forName(semic_lassname);
semi=type.newInstance();

type=Class.forName(proxyfacotory_classname);
proxyfacotory=type.newInstance();
//以下用到了依赖注入（依赖对象属性，通过反转方法改变属性值），控制反转（方法作用于对象而不是对象调用方法）技术
Method setlogic=type.getMethod("setLogic", ILogic.class);
setlogic.invoke(proxyfacotory, logic);

Method setsemi=type.getMethod("setSemi", ISemi.class);
setsemi.invoke(proxyfacotory, semi);

} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return proxyfacotory;
}
public void ReadProperties()
{
try {
InputStream in=new FileInputStream(this.filename);
prop.load(in);
logic_classname=prop.getProperty("logic_key");
semic_lassname=prop.getProperty("semi_key");
proxyfacotory_classname=prop.getProperty("proxyfactory_key");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}

package com.app;
import com.toolkit.MySpring;
import com.logic.ILogic;
import com.proxy.IProxy;
public class MyApp {

public static void main(String[] args) {
MySpring spring =new MySpring("ok.properties");
IProxy proxyFactory=(IProxy)spring.GetPorxyFactory();
ILogic logic=proxyFactory.GetProxyInstance();
int res=logic.add(12,34);
System.out.println("res="+res);
}

}

8.主调用函数

package com.app;
import com.toolkit.MySpring;
import com.logic.ILogic;
import com.proxy.IProxy;
public class MyApp {

public static void main(String[] args) {
MySpring spring =new MySpring("ok.properties");
IProxy proxyFactory=(IProxy)spring.GetPorxyFactory();
ILogic logic=proxyFactory.GetProxyInstance();
int res=logic.add(12,34);
System.out.println("res="+res);
}

}

其中.properties文件内容为

logic_key=com.logic.MyLogic
semi_key=com.semi.MySemi
proxyfactory_key=com.proxy.MyProxyFactory