Writer 源码分析

Writer是写入字符流的抽象类。子类必须实现的方法有 write(char[], int, int)、flush() 和 close()。


public abstract class Writer implements Appendable, Closeable, Flushable {
// 字符缓冲区
private char[] writeBuffer;

// 缓冲区大小
private final int writeBufferSize = 1024;

// 锁对象
protected Object lock;

// 默认构造函数,指定锁对象为流本身
protected Writer() {
this.lock = this;
}

// 使用提供的锁对象来同步重要操作
protected Writer(Object lock) {
if (lock == null) {
throw new NullPointerException();
}
this.lock = lock;
}

// 写入单个字符。c的低16位会被写入,高16位被忽略。
public void write(int c) throws IOException {
synchronized (lock) {
if (writeBuffer == null){
writeBuffer = new char[writeBufferSize];
}
writeBuffer[0] = (char) c;
write(writeBuffer, 0, 1);
}
}

// 写入字符数组
public void write(char cbuf[]) throws IOException {
write(cbuf, 0, cbuf.length);
}

// 抽象方法,由子类来实现
abstract public void write(char cbuf[], int off, int len) throws IOException;

// 写入字符串
public void write(String str) throws IOException {
write(str, 0, str.length());
}

// 写入字符串的一部分
public void write(String str, int off, int len) throws IOException {
synchronized (lock) {
char cbuf[];
if (len <= writeBufferSize) {
if (writeBuffer == null) {
writeBuffer = new char[writeBufferSize];
}
cbuf = writeBuffer;
} else {
cbuf = new char[len];
}
str.getChars(off, (off + len), cbuf, 0);
write(cbuf, 0, len);
}
}

// 将指定字符序列添加到此writer
//可能不添加整个序列,也可能添加,具体取决于字符序列 csq 的 toString 规范。例如,调用一个字符缓冲区的 toString 方法将返回一个子序列,其内容取决于缓冲区的位置和限制。
public Writer append(CharSequence csq) throws IOException {
if (csq == null)
write("null");
else
write(csq.toString());
return this;
}

// 将指定字符添加到此writer
public Writer append(char c) throws IOException {
write(c);
return this;
}

// 刷新 Writer 和 OutputStream 链中的所有缓冲区
//如果此流的预期目标是由底层操作系统提供的一个抽象(如一个文件),则刷新该流只能保证将以前写入到流的字节传递给操作系统进行写入,但不保证能将这些字节实际写入到物理设备(如磁盘驱动器)。
abstract public void flush() throws IOException;

// 关闭此流,但要先刷新它。在关闭该流之后,再调用 write() 或 flush() 将导致抛出 IOException。关闭以前关闭的流无效。
abstract public void close() throws IOException;
}
Java动态代理是一种在运行时生成代理类的机制,用于代替手动编写代理类的过程。在Java中,动态代理通常使用JDK自带的Proxy和InvocationHandler接口来实现。 下面是一个简单的动态代理示例: ```java public interface UserService { void save(); } public class UserServiceImpl implements UserService { public void save() { System.out.println("保存用户"); } } public class UserInvocationHandler implements InvocationHandler { private Object target; public UserInvocationHandler(Object target) { this.target = target; } 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) { UserService userService = new UserServiceImpl(); UserService proxy = (UserService) Proxy.newProxyInstance(userService.getClass().getClassLoader(), userService.getClass().getInterfaces(), new UserInvocationHandler(userService)); proxy.save(); } } ``` 在这个示例中,我们首先定义了一个UserService接口和一个UserServiceImpl实现类。然后我们定义了一个UserInvocationHandler类,它实现了InvocationHandler接口,该接口中只有一个invoke方法,该方法用于在代理对象上调用方法时执行的代码逻辑。在Main类中,我们通过Proxy.newProxyInstance方法创建了一个代理对象proxy,并将其强制转换为UserService类型。该方法需要三个参数:ClassLoader,该代理对象实现的接口列表和InvocationHandler实例。最后,我们通过代理对象调用了save方法。 下面是动态代理的源码分析: 在Proxy.newProxyInstance方法中,我们可以看到它调用了Proxy.getProxyClass方法,该方法用于获取代理类的Class对象。 ```java public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException { Objects.requireNonNull(h); final Class<?>[] intfs = interfaces.clone(); final SecurityManager sm = System.getSecurityManager(); if (sm != null) { checkProxyAccess(Reflection.getCallerClass(), loader, intfs); } /* * Look up or generate the designated proxy class. */ Class<?> cl = getProxyClass0(loader, intfs); /* * Invoke its constructor with the designated invocation handler. */ try { if (sm != null) { checkNewProxyPermission(Reflection.getCallerClass(), cl); } final Constructor<?> cons = cl.getConstructor(constructorParams); final InvocationHandler ih = h; if (!Modifier.isPublic(cl.getModifiers())) { AccessController.doPrivileged(new PrivilegedAction<Void>() { public Void run() { cons.setAccessible(true); return null; } }); } return cons.newInstance(new Object[]{h}); } catch (NoSuchMethodException e) { throw new InternalError(e.toString()); } catch (IllegalAccessException e) { throw new InternalError(e.toString()); } catch (InstantiationException e) { throw new InternalError(e.toString()); } catch (InvocationTargetException e) { Throwable t = e.getCause(); if (t instanceof RuntimeException) { throw (RuntimeException) t; } else { throw new InternalError(t.toString()); } } } ``` 在getProxyClass0方法中,它会先尝试从缓存中获取代理类,如果没有找到则调用ProxyClassFactory的apply方法生成代理类。 ```java private static Class<?> getProxyClass0(ClassLoader loader, Class<?>... interfaces) { if (interfaces.length > 65535) { throw new IllegalArgumentException("interface limit exceeded"); } // If the proxy class defined by the given loader implementing // the given interfaces exists, this will simply return the cached copy; // otherwise, it will create the proxy class via the ProxyClassFactory return proxyClassCache.get(loader, interfaces); } ``` 在ProxyClassFactory的apply方法中,它会使用ASM框架生成代理类的字节码。ASM是一个轻量级的Java字节码操作和分析框架,可以用于动态生成字节码。 ```java public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) { Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length); for (Class<?> intf : interfaces) { /* * Verify that the class loader resolves the name of this * interface to the same Class object. */ Class<?> interfaceClass = null; try { interfaceClass = Class.forName(intf.getName(), false, loader); } catch (ClassNotFoundException e) { } if (interfaceClass != intf) { throw new IllegalArgumentException( intf + " is not visible from class loader"); } /* * Verify that the interface is a true interface */ if (!interfaceClass.isInterface()) { throw new IllegalArgumentException( interfaceClass.getName() + " is not an interface"); } /* * Verify that this interface is not a duplicate. */ if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) { throw new IllegalArgumentException( "repeated interface: " + interfaceClass.getName()); } } /* * Choose a name for the proxy class to generate. */ String proxyName = generateProxyName(interfaces); /* * Generate the specified proxy class. */ byte[] proxyClassFile = ProxyGenerator.generateProxyClass( proxyName, interfaces, accessFlags); try { return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length); } catch (ClassFormatError e) { /* * A ClassFormatError here means that (barring bugs in the * proxy class generation code) there was some other * invalid aspect of the arguments supplied to the proxy * class creation (such as virtual machine limitations * exceeded). */ throw new IllegalArgumentException(e.toString()); } } ``` 在ProxyGenerator.generateProxyClass方法中,它使用ASM框架生成代理类的字节码。 ```java public static byte[] generateProxyClass(String var0, Class<?>[] var1, int var2) { return generateProxyClass(var0, var1, null, var2); } public static byte[] generateProxyClass(String var0, Class<?>[] var1, Class<?> var2, int var3) { ProxyGenerator var4 = new ProxyGenerator(var0, var1, var2, var3); byte[] var5 = var4.generateClassFile(); if (DUMP_CLASS) { dumpClass(var0, var5); } return var5; } ``` 在ProxyGenerator的generateClassFile方法中,它使用ASM框架生成代理类的字节码。 ```java public byte[] generateClassFile() { this.createClassInfo(); this.createFieldInfo(); this.createConstructorInfo(); this.createMethodInfo(); this.createAttributeInfo(); return this.classWriter.toByteArray(); } ``` 总体来说,Java动态代理实现的核心在于使用ASM框架生成代理类的字节码。ASM框架提供了一种轻量级的生成和修改Java字节码的方式,可以很方便地生成符合Java规范的字节码。通过动态生成代理类,我们可以省去手动编写代理类的繁琐过程,并且可以使代理类更加灵活和易于维护。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值