java浅拷贝深拷贝 在Java中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）是两个常见的对象拷贝方式。它们的主要区别在于它们处理对象中的引用类型字段的方式。1. 浅拷贝（Shallow Copy）浅拷贝仅拷贝对象本身以及对象中所有的基本数据类型字段，对于引用类型字段（如对象、数组等），仅复制其引用（即指针），而不复制实际的对象。这意味着原对象和拷贝对象中的引用类型字段指向同一个内存地址，因此改变一个对象中的引用类型字段可能会影响到另一个对象。实现方式：实现Cloneable接口并重写clone()方法。代码示例：class Address { String city; public Address(String city) { this.city = city; } } class Person implements Cloneable { String name; Address address; public Person(String name, Address address) { this.name = name; this.address = address; } @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); // 浅拷贝 } } public class ShallowCopyExample { public static void main(String[] args) throws CloneNotSupportedException { Address address = new Address("New York"); Person person1 = new Person("John", address); Person person2 (Person) person1.clone(); System.out.println(person1.address.city); // New York System.out.println(person2.address.city); // New York person2.address.city = "San Francisco"; System.out.println(person1.address.city); // San Francisco System.out.println(person2.address.city); // San Francisco } }应用场景：浅拷贝适用于对象结构简单且不包含复杂的嵌套对象的情况。因为浅拷贝的速度较快，适合对性能有较高要求但不涉及深层嵌套结构的场景。2. 深拷贝（Deep Copy）深拷贝不仅拷贝对象本身，还会递归地拷贝对象中所有引用类型字段所指向的对象。这意味着原对象和拷贝对象中的引用类型字段互不影响，修改一个对象中的引用类型字段不会影响到另一个对象。实现方式：重写clone()方法，手动拷贝所有的引用类型字段。使用序列化和反序列化实现深拷贝。代码示例：class Address implements Cloneable { String city; public Address(String city) { this.city = city; } @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } } class Person implements Cloneable { String name; Address address; public Person(String name, Address address) { this.name = name; this.address = address; } @Override protected Object clone() throws CloneNotSupportedException { Person clonedPerson = (Person) super.clone(); clonedPerson.address = (Address) address.clone(); // 深拷贝 return clonedPerson; } } public class DeepCopyExample { public static void main(String[] args) throws CloneNotSupportedException { Address address = new Address("New York"); Person person1 = new Person("John", address); Person person2 = (Person) person1.clone(); System.out.println(person1.address.city); // New York System.out.println(person2.address.city); // New York person2.address.city = "San Francisco"; System.out.println(person1.address.city); // New York System.out.println(person2.address.city); // San Francisco } }应用场景：深拷贝适用于对象结构复杂且包含多个嵌套引用类型字段的场景，尤其是在这些引用类型字段是可变对象时。深拷贝确保拷贝后的对象与原对象完全独立，不会互相影响。总结浅拷贝：仅复制对象及其基本数据类型字段，引用类型字段只复制引用。适用于简单的对象结构。深拷贝：复制对象及其所有引用类型字段所指向的对象。适用于复杂对象结构，确保深层次的独立性。根据具体需求选择合适的拷贝方式可以有效地避免不必要的副作用并提高程序的性能。

Java动态代理rpc Java 动态代理在远程过程调用（RPC）中非常有用，可以隐藏网络通信的复杂性，使得远程调用看起来像是本地方法调用。场景说明假设我们有一个简单的服务接口 CalculatorService，它提供了加法和减法的功能。我们希望客户端可以通过动态代理的方式调用这个服务接口，实际上这些调用会通过网络发送到远程的服务端进行计算。1. 定义服务接口首先定义一个服务接口 CalculatorService：// 服务接口 public interface CalculatorService { int add(int a, int b); int subtract(int a, int b); }2. 实现服务端服务端实现了 CalculatorService 接口，并在远程提供服务：import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.net.ServerSocket; import java.net.Socket; // 服务端实现类 public class CalculatorServiceImpl implements CalculatorService { @Override public int add(int a, int b) { return a + b; } @Override public int subtract(int a, int b) { return a - b; } public static void main(String[] args) throws Exception { ServerSocket serverSocket = new ServerSocket(8080); System.out.println("服务端启动，等待连接..."); while (true) { Socket clientSocket = serverSocket.accept(); ObjectInputStream input = new ObjectInputStream(clientSocket.getInputStream()); String methodName = input.readUTF(); int a = input.readInt(); int b = input.readInt(); ObjectOutputStream output = new ObjectOutputStream(clientSocket.getOutputStream()); CalculatorService service = new CalculatorServiceImpl(); if (methodName.equals("add")) { output.writeInt(service.add(a, b)); } else if (methodName.equals("subtract")) { output.writeInt(service.subtract(a, b)); } output.flush(); clientSocket.close(); } } }3. 实现客户端动态代理客户端使用动态代理调用远程服务：import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.net.Socket; // 动态代理处理器 public class RpcInvocationHandler implements InvocationHandler { private String host; private int port; public RpcInvocationHandler(String host, int port) { this.host = host; this.port = port; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Socket socket = new Socket(host, port); ObjectOutputStream output = new ObjectOutputStream(socket.getOutputStream()); output.writeUTF(method.getName()); for (Object arg : args) { output.writeObject(arg); } ObjectInputStream input = new ObjectInputStream(socket.getInputStream()); Object result = input.readObject(); input.close(); output.close(); socket.close(); return result; } } // 客户端代码 public class RpcClient { @SuppressWarnings("unchecked") public static <T> T getProxy(Class<T> serviceClass, String host, int port) { return (T) Proxy.newProxyInstance(serviceClass.getClassLoader(), new Class<?>[]{serviceClass}, new RpcInvocationHandler(host, port)); } public static void main(String[] args) { CalculatorService service = RpcClient.getProxy(CalculatorService.class, "localhost", 8080); int result1 = service.add(10, 5); int result2 = service.subtract(10, 5); System.out.println("加法结果: " + result1); System.out.println("减法结果: " + result2); } }4. 运行说明服务端：运行 CalculatorServiceImpl，它将开启一个 TCP 服务器，在 8080 端口等待客户端请求。客户端：运行 RpcClient，通过动态代理获得 CalculatorService 的代理对象，并调用 add 和 subtract 方法。这些方法调用将通过网络发送到服务端，由服务端处理并返回结果。5. 执行结果运行客户端后，输出如下：加法结果: 15 减法结果: 56. 解析服务端：简单实现了一个 TCP 服务器，通过 ObjectInputStream 和 ObjectOutputStream 来接收和发送请求。客户端：使用 JDK 动态代理，通过 RpcInvocationHandler 拦截方法调用，将方法名和参数序列化后发送给服务端，再从服务端获取结果。

代理模式 代理模式（Proxy Pattern）是设计模式中的一种结构型模式。它为其他对象提供一种代理以控制对这个对象的访问。在 Java 中，代理模式有多种实现方式，主要分为静态代理和动态代理。1. 代理模式的基本概念意图：代理模式通过创建一个代理对象来代替实际对象，并且可以控制对实际对象的访问。代理对象和实际对象通常实现相同的接口或继承相同的类。结构：Subject（抽象主题接口/类）：定义了真实对象和代理对象的公共接口或父类。RealSubject（真实主题类）：实现了抽象主题接口，是代理对象所代表的真实对象。Proxy（代理类）：持有一个对真实对象的引用，实现了抽象主题接口，并在调用时对真实对象进行操作。适用场景：需要对原对象的功能进行扩展或控制，而不改变原对象的代码。需要对某个类的访问进行控制，比如延迟加载、安全代理、远程代理等。2. 静态代理特点：预先定义：代理类在编译时就已经创建好了，代理类和真实类需要实现相同的接口。代理行为固定：代理类的行为是静态的，不能在运行时改变。优缺点：优点：实现简单，容易理解，能够在编译时进行类型检查。缺点：代理类与真实类高度耦合，代理类过多会导致代码冗余，不适合扩展性需求高的场景。示例代码：// 定义接口 public interface Subject { void request(); } // 真实主题类 public class RealSubject implements Subject { @Override public void request() { System.out.println("真实主题处理请求"); } } // 代理类 public class Proxy implements Subject { private RealSubject realSubject; public Proxy(RealSubject realSubject) { this.realSubject = realSubject; } @Override public void request() { System.out.println("代理开始处理"); realSubject.request(); System.out.println("代理完成处理"); } } // 测试代码 public class Main { public static void main(String[] args) { RealSubject realSubject = new RealSubject(); Proxy proxy = new Proxy(realSubject); proxy.request(); } }3. 动态代理特点：动态生成：动态代理类在运行时由 JVM 动态生成，不需要事先定义代理类。灵活性高：可以在运行时灵活地决定代理行为。实现方式：JDK 动态代理：基于反射机制，只能代理实现了接口的类。CGLIB 动态代理：基于字节码生成，可以代理没有实现接口的类，常用于 Spring 框架。优缺点：优点：减少了静态代理的冗余代码，增强了扩展性，可以动态地为多个对象创建代理。缺点：性能略低于静态代理，调试较为复杂，尤其是对生成的动态代理类进行调试。JDK 动态代理示例代码：import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; // 定义接口 public interface Subject { void request(); } // 真实主题类 public class RealSubject implements Subject { @Override public void request() { System.out.println("真实主题处理请求"); } } // 动态代理处理器 public class DynamicProxyHandler implements InvocationHandler { private Object target; public DynamicProxyHandler(Object target) { this.target = target; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("代理开始处理"); Object result = method.invoke(target, args); // 调用真实对象的方法 System.out.println("代理完成处理"); return result; } } // 测试代码 public class Main { public static void main(String[] args) { RealSubject realSubject = new RealSubject(); Subject proxyInstance = (Subject) Proxy.newProxyInstance( realSubject.getClass().getClassLoader(), realSubject.getClass().getInterfaces(), new DynamicProxyHandler(realSubject) ); proxyInstance.request(); } }4. 代理模式的常见应用安全代理：控制对原始对象的访问，确保安全性。延迟加载：在需要时才创建或加载实际对象，以提高性能。远程代理：为远程对象提供本地代理，使远程调用看起来像本地调用。虚拟代理：控制对象的访问以延迟实际对象的创建和初始化。保护代理：通过代理来控制对象的访问权限。5. 总结代理模式是一种非常有用的设计模式，它通过引入代理对象来控制对实际对象的访问。静态代理适合简单和固定的场景，而动态代理则提供了更强的灵活性和扩展性。理解代理模式的使用场景和实现方式，可以帮助开发者编写更灵活、更易维护的代码。