黑马程序员_高薪技术_9



----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------

第一点：加载配置文件的方法：

FileInputStream("文件位置");这个文件位置的相对位置，是相对于工程的。

类名.class.getClassLoader().getResourceAsStream("文件位置");这个文件位置相对的位置是相对于源代码的src里面的。还有一种方法：类名.class.getResourceAsStream("文件名")。这样的加载方法的文件要存放到和class文件一个位置上。

 

第二点：JavaBean的概念。

JavaBean 是一种JAVA语言写成的可重用组件。为写成JavaBean，类必须是具体的和公共的，并且具有无参数的构造器。JavaBean 通过提供符合一致性设计模式的公共方法将内部域暴露成员属性（get和set方法）。属性名称符合这种模式，其他Java 类可以通过自身机制发现和操作这些JavaBean 属性。下面是设计的一个JavaBean

 

public class Person {
private String name;
private int age;
Person() {
	name = "";
	age = 0;
}
public void setName(String name) {
	this.name = name;
}
public void setAge(int age) {
	this.age = age;
}

public String getName() {
	return name;
}

public int getAge() {
	return age;
}
@Override
public String toString() {
	return "Person [name=" + name + ", age=" + age + "]";
}
}
JavaBean可以被专门的Bean工具操作。如，BeanUtils
import java.util.Properties;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.beanutils.PropertyUtils;

public class TestRef {
public static void main(String[] args) throws Exception {
	Person person = Person.class.newInstance();
	BeanUtils.setProperty(person, "name", "abc");
	BeanUtils.setProperty(person, "age", "20");
	PropertyUtils.setProperty(person, "age", 2);
	System.out.println(person);
}
}

这种使用工具来注射值的方式很简单。假如不这样做的话，就应该先得到一个PropertyDescriptor对象，这个对象可以得到数据的get或者set方法。方法演示如下。

 

private static void inject(Class class1, Person person)
		throws IntrospectionException, IllegalAccessException,
		InvocationTargetException {
	PropertyDescriptor propertyDescriptor = new PropertyDescriptor("name", class1);
	propertyDescriptor.getWriteMethod().invoke(person, "lailongwei");
	PropertyDescriptor propertyDescriptor2 = new PropertyDescriptor("age", class1);
	propertyDescriptor2.getWriteMethod().invoke(person, 20);
}

 

第三点：java代理模式。由于枝节代码和java面向对象的理论相违背，所以java中用代理的方法把枝节代码给抽取出来。这里说的枝节代码，一般是事务，安全，日志等等。

Java的代理构架图如下：

 

代理类和目标类要实现共同的接口。然后客户端不直接调用目标类的功能，而是调用代理类的功能，代理类的功能会调用目标类的功能。工作原理图如下

 

得到代理类的过程：调用Proxy的静态方法newProxyInstance(classsLoader,Class[], InvocationHandler)。第一个参数是类加载器，第二个参数是目标类实现的接口，是个数组，第三个是一个InvocationHandler的之类。这和动态代理的原理是有关的。因为调用代理类的方法，就会使用InvocationHandler对象的invoke(Object,Method,Object[] args)方法，这个方法第一个参数是代理类，第二个参数调用的方法，第三个参数是Method的参数。

下面是做的代理器演示：

1、业务代码的接口 Advice

package it.cast.day3;

public interface Advice {
void before();
void after();
}

2、实现上面的接口

package it.cast.day3;
public class ImpleAdvice implements Advice{
@Override
public void before() {
	System.out.println("before");
}
@Override
public void after() {
	// TODO Auto-generated method stub
	System.out.println("after");
}
}

3，一个InvocationHandler的子类

package it.cast.day3;
import java.lang.reflect.InvocationHandler;
public class NewInvocationHandler implements InvocationHandler {
private Advice advice;
private Object targe;
public NewInvocationHandler(Advice advice, Object target) {
	this.advice = advice;
	this.targe = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
		throws Throwable {
	advice.before();
	Object retVal = method.invoke(targe, args);
	advice.after();
	return retVal;
}
}

4，配置文件 名字为：prop.properties

className=java.util.ArrayList
adviceName=it.cast.day3.ImpleAdvice

 

5，使用部分

package it.cast.day3;
import java.io.FileInputStream;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Properties;
public class ProxyTest {
public static void main(String[] args) throws Exception{
	Properties properties = new Properties();
	InputStream inputStream = new 	FileInputStream("prop.properties");
	properties.load(inputStream);
	String className = properties.getProperty("className");
	String adviceName = properties.getProperty("adviceName");
	Advice advice = (Advice) 	Class.forName(adviceName).newInstance();
	Object target = Class.forName(className).newInstance();
	Collection coll = (Collection)getProxy(advice, target);
	coll.add("abc");
	coll.add("abc1");
	coll.add("abc2");
	System.out.println(coll);
}

private static Object getProxy(Advice advice, Object target) {
	Object coll = (Object) Proxy.newProxyInstance(target.getClass().getClassLoader(),
			target.getClass().getInterfaces(),
			new NewInvocationHandler(advice, target));
	return coll;
}
}

这样一个动态代理类就生成了。

 

----------------------- android培训、java培训、java学习型技术博客、期待与您交流！ ----------------------

详情请查看：http://edu.youkuaiyun.com/heima