一、什么是反射？

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法，对于任意一个对象，都能够调用它的任意一个方法和属性，这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

二、什么是 java 序列化？什么情况下需要序列化？

序列化：将 Java 对象转换成字节流的过程。

反序列化：将字节流转换成 Java 对象的过程。

当 Java 对象需要在网络上传输 或者 持久化存储到文件中时，就需要对 Java 对象进行序列化处理。

三、怎实现序列化？

序列化的实现：类实现 Serializable 接口，这个接口没有需要实现的方法。实现 Serializable 接口是为了告诉 jvm 这个类的对象可以被序列化。

注意事项：

  • 某个类可以被序列化，则其子类也可以被序列化
  • 声明为 static 和 transient 的成员变量，不能被序列化。static 成员变量是描述类级别的属性，transient 表示临时数据
  • 反序列化读取序列化对象的顺序要保持一致
package constxiong.interview;
 
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
 
/**
 * 测试序列化，反序列化
 */
public class TestSerializable implements Serializable {
 
	private static final long serialVersionUID = 5887391604554532906L;
	
	private int id;
	
	private String name;
 
	public TestSerializable(int id, String name) {
		this.id = id;
		this.name = name;
	}
	
	@Override
	public String toString() {
		return "TestSerializable [id=" + id + ", name=" + name + "]";
	}
 
	@SuppressWarnings("resource")
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		//序列化
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("TestSerializable.obj"));
		oos.writeObject("测试序列化");
		oos.writeObject(618);
		TestSerializable test = new TestSerializable(1, "ConstXiong");
		oos.writeObject(test);
		
		//反序列化
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream("TestSerializable.obj"));
		System.out.println((String)ois.readObject());
		System.out.println((Integer)ois.readObject());
		System.out.println((TestSerializable)ois.readObject());
	}
 
}

四、动态代理是什么？有几种动态代理？？有哪些应用？？？

动态代理：当我们需要给某个类或者接口中的方法添加一些额外的功能比如日志、事务的时候,可以通过创建一个代理类来实现这些功能；该代理类既包含了原有类的完整功能，同时在这些功能的基础上添加了其他的逻辑。这个代理类不是事先定义好的，而是动态生成的，比较灵活；

两种种动态代理：

  1. java动态代理：java动态代理有个缺点就是要被代理的类必须实现一个接口，否则没法代理
  2. cglib动态代理：cglib动态代理可以对没有实现接口的类进行代理

动态代理的应用：AOP

五、怎么实现动态代理？

java的动态代理Demo：

  • 编写一个常规方法的接口,这里我们定义一个用户接口,并且编写保存用户方法save()
/**
 * 用户接口
 */
public interface UserDao {
    public void save();//定义保存用户的方法
}
  • 编写用户接口的实现类，并且实现接口方法save()
/**
*  用户接口实现类
*/
public class UserDaoImp implements UserDao {
    @Override
    public void save() {
        System.out.println("保存用户");
        System.out.println("保存成功啦");
    }
}
  • 编写自己的MyInvocationHandler实现InvocationHandler接口，重写invoke方法来添加我们需要添加的额外功能
public class MyInvocationHandler implements InvocationHandler {
    //被动态代理的对象
    private Object target;
 
    public MyInvocationHandler(Object target) {
        this.target = target;
    }
 
    /**
     * 这个代理类到底是多了什么额外功能
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("开始记录日志，方法开始执行...");
        method.invoke(target,args);
        System.out.println("结束记录日志，方法结束执行...");
        return null;
    }
}
  • 通过Proxy来生成代理对象,有俩种方式
public static void main(String[] args) throws Exception {
    /**
     * 方式一
     */
    //通过调用动态代理类Proxy的newProxyInstance()生成代理对象
    UserDao userDao= (UserDao) Proxy.newProxyInstance(UserDao.class.getClassLoader(),
            new Class<?>[] { UserDao.class }, // 被代理类的接口
            new MyInvocationHandler(new UserDaoImp()));//要被代理的对象
    userDao.save();
    /**
     * 方式二
     */
    //编写invocationhandler实现额外功能
    InvocationHandler handler = new MyInvocationHandler(new UserDaoImp());
    //通过调用动态代理类Proxy的getProxyClass()方法获取要代理的类
    Class<?> proxyClass = Proxy.getProxyClass(UserDao.class.getClassLoader(), UserDao.class);
    //通过代理类生成代理对象
    UserDao userDao1 = (UserDao) proxyClass.getConstructor(InvocationHandler.class).
            newInstance(handler);
    userDao1.save();
 
}