type of keys
+ * @param type of parameters
+ * @param type of values
+ */
+final class WeakCache {}
+
+
+```
+public V get(K key, P parameter) {
+ Objects.requireNonNull(parameter);
+
+ expungeStaleEntries();
+
+ Object cacheKey = CacheKey.valueOf(key, refQueue);
+
+ // lazily install the 2nd level valuesMap for the particular cacheKey
+ ConcurrentMap> valuesMap = map.get(cacheKey);
+ if (valuesMap == null) {
+ ConcurrentMap> oldValuesMap
+ = map.putIfAbsent(cacheKey,
+ valuesMap = new ConcurrentHashMap<>());
+ if (oldValuesMap != null) {
+ valuesMap = oldValuesMap;
+ }
+ }
+
+ // create subKey and retrieve the possible Supplier stored by that
+ // subKey from valuesMap
+ Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
+ Supplier supplier = valuesMap.get(subKey);
+ Factory factory = null;
+
+ while (true) {
+ if (supplier != null) {
+ // supplier might be a Factory or a CacheValue instance
+```
+
+- // supplier是Factory,这个类定义在WeakCache的内部。
+ V value = supplier.get();
+ if (value != null) {
+ return value;
+ }
+ }
+ // else no supplier in cache
+ // or a supplier that returned null (could be a cleared CacheValue
+ // or a Factory that wasn't successful in installing the CacheValue)
+
+ // lazily construct a Factory
+ if (factory == null) {
+ factory = new Factory(key, parameter, subKey, valuesMap);
+ }
+
+ if (supplier == null) {
+ supplier = valuesMap.putIfAbsent(subKey, factory);
+ if (supplier == null) {
+ // successfully installed Factory
+ supplier = factory;
+ }
+ // else retry with winning supplier
+ } else {
+ if (valuesMap.replace(subKey, supplier, factory)) {
+ // successfully replaced
+ // cleared CacheEntry / unsuccessful Factory
+ // with our Factory
+ supplier = factory;
+ } else {
+ // retry with current supplier
+ supplier = valuesMap.get(subKey);
+ }
+ }
+ }
+}
+
+- Factory
+
+```
+private final class Factory implements Supplier {
+
+ private final K key;
+ private final P parameter;
+ private final Object subKey;
+ private final ConcurrentMap> valuesMap;
+
+ Factory(K key, P parameter, Object subKey,
+ ConcurrentMap> valuesMap) {
+ this.key = key;
+ this.parameter = parameter;
+ this.subKey = subKey;
+ this.valuesMap = valuesMap;
+ }
+
+ @Override
+ public synchronized V get() { // serialize access
+ // re-check
+ Supplier supplier = valuesMap.get(subKey);
+ if (supplier != this) {
+ // something changed while we were waiting:
+ // might be that we were replaced by a CacheValue
+ // or were removed because of failure ->
+ // return null to signal WeakCache.get() to retry
+ // the loop
+ return null;
+ }
+ // else still us (supplier == this)
+
+ // create new value
+```
+
+- // 创建新的class
+ V value = null;
+ try {
+ value = Objects.requireNonNull(valueFactory.apply(key, parameter));
+ } finally {
+ if (value == null) { // remove us on failure
+ valuesMap.remove(subKey, this);
+ }
+ }
+ // the only path to reach here is with non-null value
+ assert value != null;
+
+ // wrap value with CacheValue (WeakReference)
+ CacheValue cacheValue = new CacheValue<>(value);
+
+ // try replacing us with CacheValue (this should always succeed)
+ if (valuesMap.replace(subKey, this, cacheValue)) {
+ // put also in reverseMap
+ reverseMap.put(cacheValue, Boolean.TRUE);
+ } else {
+ throw new AssertionError("Should not reach here");
+ }
+
+ // successfully replaced us with new CacheValue -> return the value
+ // wrapped by it
+ return value;
+ }
+}
+
+
+
+```
+private static final class ProxyClassFactory
+ implements BiFunction[], Class>
+{
+ // prefix for all proxy class names
+ private static final String proxyClassNamePrefix = "$Proxy";
+
+ // next number to use for generation of unique proxy class names
+ private static final AtomicLong nextUniqueNumber = new AtomicLong();
+
+ @Override
+ public Class apply(ClassLoader loader, Class[] interfaces) {
+
+ Map, 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 Class object actually represents an
+ * 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());
+ }
+ }
+
+ String proxyPkg = null; // package to define proxy class in
+ int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
+
+ /*
+ * Record the package of a non-public proxy interface so that the
+ * proxy class will be defined in the same package. Verify that
+ * all non-public proxy interfaces are in the same package.
+ */
+ for (Class intf : interfaces) {
+ int flags = intf.getModifiers();
+ if (!Modifier.isPublic(flags)) {
+ accessFlags = Modifier.FINAL;
+ String name = intf.getName();
+ int n = name.lastIndexOf('.');
+ String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
+ if (proxyPkg == null) {
+ proxyPkg = pkg;
+ } else if (!pkg.equals(proxyPkg)) {
+ throw new IllegalArgumentException(
+ "non-public interfaces from different packages");
+ }
+ }
+ }
+
+ if (proxyPkg == null) {
+ // if no non-public proxy interfaces, use com.sun.proxy package
+ proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
+ }
+
+ /*
+ * Choose a name for the proxy class to generate.
+ */
+ long num = nextUniqueNumber.getAndIncrement();
+ String proxyName = proxyPkg + proxyClassNamePrefix + num;
+
+ /*
+ * 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());
+ }
+ }
+}
+```
+
+
+- 重点！
+
+```
+/**
+ * Generate a proxy class given a name and a list of proxy interfaces.
+ *
+ * @param name the class name of the proxy class
+ * @param interfaces proxy interfaces
+ * @param accessFlags access flags of the proxy class
+*/
+public static byte[] generateProxyClass(final String name,
+ Class[] interfaces,
+ int accessFlags)
+{
+ ProxyGenerator gen = new ProxyGenerator(name, interfaces, accessFlags);
+ final byte[] classFile = gen.generateClassFile();
+
+ if (saveGeneratedFiles) {
+ java.security.AccessController.doPrivileged(
+ new java.security.PrivilegedAction() {
+ public Void run() {
+ try {
+ int i = name.lastIndexOf('.');
+ Path path;
+ if (i > 0) {
+ Path dir = Paths.get(name.substring(0, i).replace('.', File.separatorChar));
+ Files.createDirectories(dir);
+ path = dir.resolve(name.substring(i+1, name.length()) + ".class");
+ } else {
+ path = Paths.get(name + ".class");
+ }
+ Files.write(path, classFile);
+ return null;
+ } catch (IOException e) {
+ throw new InternalError(
+ "I/O exception saving generated file: " + e);
+ }
+ }
+ });
+ }
+
+ return classFile;
+}
+```
+
+- ProxyGenerator#generateClassFIle
+
+
+```
+/**
+ * Generate a class file for the proxy class. This method drives the
+ * class file generation process.
+ */
+private byte[] generateClassFile() {
+
+ /* ============================================================
+ * Step 1: Assemble ProxyMethod objects for all methods to
+ * generate proxy dispatching code for.
+ */
+
+ /*
+ * Record that proxy methods are needed for the hashCode, equals,
+ * and toString methods of java.lang.Object. This is done before
+ * the methods from the proxy interfaces so that the methods from
+ * java.lang.Object take precedence over duplicate methods in the
+ * proxy interfaces.
+ */
+ addProxyMethod(hashCodeMethod, Object.class);
+ addProxyMethod(equalsMethod, Object.class);
+ addProxyMethod(toStringMethod, Object.class);
+
+ /*
+ * Now record all of the methods from the proxy interfaces, giving
+ * earlier interfaces precedence over later ones with duplicate
+ * methods.
+ */
+ for (Class intf : interfaces) {
+ for (Method m : intf.getMethods()) {
+ addProxyMethod(m, intf);
+ }
+ }
+
+ /*
+ * For each set of proxy methods with the same signature,
+ * verify that the methods' return types are compatible.
+ */
+ for (List sigmethods : proxyMethods.values()) {
+ checkReturnTypes(sigmethods);
+ }
+
+ /* ============================================================
+ * Step 2: Assemble FieldInfo and MethodInfo structs for all of
+ * fields and methods in the class we are generating.
+ */
+ try {
+ methods.add(generateConstructor());
+
+ for (List sigmethods : proxyMethods.values()) {
+ for (ProxyMethod pm : sigmethods) {
+
+ // add static field for method's Method object
+ fields.add(new FieldInfo(pm.methodFieldName,
+ "Ljava/lang/reflect/Method;",
+ ACC_PRIVATE | ACC_STATIC));
+
+ // generate code for proxy method and add it
+ methods.add(pm.generateMethod());
+ }
+ }
+
+ methods.add(generateStaticInitializer());
+
+ } catch (IOException e) {
+ throw new InternalError("unexpected I/O Exception", e);
+ }
+
+ if (methods.size() > 65535) {
+ throw new IllegalArgumentException("method limit exceeded");
+ }
+ if (fields.size() > 65535) {
+ throw new IllegalArgumentException("field limit exceeded");
+ }
+
+ /* ============================================================
+ * Step 3: Write the final class file.
+ */
+
+ /*
+ * Make sure that constant pool indexes are reserved for the
+ * following items before starting to write the final class file.
+ */
+ cp.getClass(dotToSlash(className));
+ cp.getClass(superclassName);
+ for (Class intf: interfaces) {
+ cp.getClass(dotToSlash(intf.getName()));
+ }
+
+ /*
+ * Disallow new constant pool additions beyond this point, since
+ * we are about to write the final constant pool table.
+ */
+ cp.setReadOnly();
+
+ ByteArrayOutputStream bout = new ByteArrayOutputStream();
+ DataOutputStream dout = new DataOutputStream(bout);
+
+ try {
+ /*
+ * Write all the items of the "ClassFile" structure.
+ * See JVMS section 4.1.
+ */
+ // u4 magic;
+ dout.writeInt(0xCAFEBABE);
+ // u2 minor_version;
+ dout.writeShort(CLASSFILE_MINOR_VERSION);
+ // u2 major_version;
+ dout.writeShort(CLASSFILE_MAJOR_VERSION);
+
+ cp.write(dout); // (write constant pool)
+
+ // u2 access_flags;
+ dout.writeShort(accessFlags);
+ // u2 this_class;
+ dout.writeShort(cp.getClass(dotToSlash(className)));
+ // u2 super_class;
+ dout.writeShort(cp.getClass(superclassName));
+
+ // u2 interfaces_count;
+ dout.writeShort(interfaces.length);
+ // u2 interfaces[interfaces_count];
+ for (Class intf : interfaces) {
+ dout.writeShort(cp.getClass(
+ dotToSlash(intf.getName())));
+ }
+
+ // u2 fields_count;
+ dout.writeShort(fields.size());
+ // field_info fields[fields_count];
+ for (FieldInfo f : fields) {
+ f.write(dout);
+ }
+
+ // u2 methods_count;
+ dout.writeShort(methods.size());
+ // method_info methods[methods_count];
+ for (MethodInfo m : methods) {
+ m.write(dout);
+ }
+
+ // u2 attributes_count;
+ dout.writeShort(0); // (no ClassFile attributes for proxy classes)
+
+ } catch (IOException e) {
+ throw new InternalError("unexpected I/O Exception", e);
+ }
+
+ return bout.toByteArray();
+}
+```
+
+
+### 2)getConstructor（获取代理类的构造方法)
+### 3)newInstance（初始化代理对象)
+
+## CGLIB动态代理 使用
+- CGLIB(Code Generation Library)是一个基于ASM的字节码生成库，它允许我们在运行时对字节码进行修改和动态生成。CGLIB通过继承方式实现代理。
+- CGLIB的核心类：
+- net.sf.cglib.proxy.Enhancer – 主要的增强类
+- net.sf.cglib.proxy.MethodInterceptor – 主要的方法拦截类，它是Callback接口的子接口，需要用户实现
+- net.sf.cglib.proxy.MethodProxy – JDK的java.lang.reflect.Method类的代理类，可以方便的实现对源对象方法的调用,如使用：
+
+- Object o = methodProxy.invokeSuper(proxy, args);//虽然第一个参数是被代理对象，也不会出现死循环的问题。
+- net.sf.cglib.proxy.MethodInterceptor接口是最通用的回调（callback)类型，它经常被基于代理的AOP用来实现拦截（intercept)方法的调用。这个接口只定义了一个方法
+
+```
+public Object intercept(Object object, java.lang.reflect.Method method,
+```
+
+- Object[] args, MethodProxy proxy) throws Throwable;
+- 第一个参数是代理对像，第二和第三个参数分别是拦截的方法和方法的参数。原来的方法可能通过使用java.lang.reflect.Method对象的一般反射调用，或者使用 net.sf.cglib.proxy.MethodProxy对象调用。net.sf.cglib.proxy.MethodProxy通常被首选使用，因为它更快。
+
+```
+public class CglibProxy implements MethodInterceptor {
+```
+
+- @Override
+
+```
+ public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
+```
+
+- System.out.println("++++++before " + methodProxy.getSuperName() + "++++++");
+- System.out.println(method.getName());
+- Object o1 = methodProxy.invokeSuper(o, args);
+- System.out.println("++++++before " + methodProxy.getSuperName() + "++++++");
+- return o1;
+- }
+- }
+
+
+```
+public class Main {
+```
+
+
+```
+ public static void main(String[] args) {
+```
+
+- CglibProxy cglibProxy = new CglibProxy();
+-
+- Enhancer enhancer = new Enhancer();
+- enhancer.setSuperclass(UserServiceImpl.class);
+- enhancer.setCallback(cglibProxy);
+-
+- UserService o = (UserService)enhancer.create();
+ - o.getName(1);
+ - o.getAge(1);
+- }
+- }
+- 我们通过CGLIB的Enhancer来指定要代理的目标对象、实际处理代理逻辑的对象，最终通过调用create()方法得到代理对象，对这个对象所有非final方法的调用都会转发给MethodInterceptor.intercept()方法，在intercept()方法里我们可以加入任何逻辑，比如修改方法参数，加入日志功能、安全检查功能等；通过调用MethodProxy.invokeSuper()方法，我们将调用转发给原始对象，具体到本例，就是HelloConcrete的具体方法。CGLIG中MethodInterceptor的作用跟JDK代理中的InvocationHandler很类似，都是方法调用的中转站。
+- 注意：对于从Object中继承的方法，CGLIB代理也会进行代理，如hashCode()、equals()、toString()等，但是getClass()、wait()等方法不会，因为它是final方法，CGLIB无法代理。
+- 既然是继承就不得不考虑final的问题。我们知道final类型不能有子类，所以CGLIB不能代理final类型。
+- final方法是不能重载的，所以也不能通过CGLIB代理，遇到这种情况不会抛异常，而是会跳过final方法只代理其他方法。
+
+## CGLIB动态代理 原理
+- 1、生成代理类Class的二进制字节码（基于ASM)；
+- 2、通过 Class.forName加载二进制字节码，生成Class对象；
+- 3、通过反射机制获取实例构造，并初始化代理类对象。
+
+- 调用委托类的方法是使用invokeSuper
+
+```
+public Object invokeSuper(Object obj, Object[] args) throws Throwable {
+ try {
+ init();
+ FastClassInfo fci = fastClassInfo;
+ return fci.f2.invoke(fci.i2, obj, args);
+ } catch (InvocationTargetException e) {
+ throw e.getTargetException();
+ }
+}
+```
+
+
+
+```
+private static class FastClassInfo
+{
+ FastClass f1;
+ FastClass f2;
+ int i1;
+ int i2;
+}
+```
+
+- f1指向委托类对象，f2指向代理类对象
+- i1是被代理的方法在对象中的索引位置
+- i2是CGLIB$被代理的方法$0在对象中的索引位置
+### FastClass实现机制
+- FastClass其实就是对Class对象进行特殊处理，提出下标概念index，通过索引保存方法的引用信息，将原先的反射调用，转化为方法的直接调用，从而体现所谓的fast。
+
+
+
+- 在FastTest中有两个方法， getIndex中对Test类的每个方法根据hash建立索引， invoke根据指定的索引，直接调用目标方法，避免了反射调用。
+
+
+-
+
+# 1.18 反射
+- Java的动态性体现在：反射机制、动态执行脚本语言、动态操作字节码
+- 反射：在运行时加载、探知、使用编译时未知的类。
+
+- Class.forName使用的类加载器是调用者的类加载器
+## Class
+- 表示Java中的类型（class、interface、enum、annotation、primitive type、void)本身。
+
+
+- 一个类被加载之后，JVM会创建一个对应该类的Class对象，类的整个结构信息会放在相应的Class对象中。
+- 这个Class对象就像一个镜子一样，从中可以看到类的所有信息。
+- 反射的核心就是Class
+
+- 如果多次执行forName等加载类的方法，类只会被加载一次；一个类只会形成一个Class对象，无论执行多少次加载类的方法，获得的Class都是一样的。
+## 用途
+
+## 性能
+- 反射带来灵活性的同时，也有降低程序执行效率的弊端
+- setAccessible方法不仅可以标记某些私有的属性方法为可访问的属性方法，并且可以提高程序的执行效率
+
+- 实际上是启用和禁用访问安全检查的开关。如果做检查就会降低效率；关闭检查就可以提高效率。
+- 反射调用方法比直接调用要慢大约30倍，如果跳过安全检查的话比直接调用要慢大约7倍
+- 开启和不开启安全检查对于反射而言可能会差4倍的执行效率。
+- 为什么慢?
+ - 1)验证等防御代码过于繁琐，这一步本来在link阶段，现在却在计算时进行验证
+ - 2)产生很多临时对象，造成GC与计算时间消耗
+ - 3)由于缺少上下文，丢失了很多运行时的优化，比如JIT(它可以看作JVM的重要评测标准之一)
+- 当然，现代JVM也不是非常慢了，它能够对反射代码进行缓存以及通过方法计数器同样实现JIT优化，所以反射不一定慢。
+## 实现
+- 反射在Java中可以直接调用，不过最终调用的仍是native方法，以下为主流反射操作的实现。
+
+### Class.forName的实现
+- Class.forName可以通过包名寻找Class对象，比如Class.forName("java.lang.String")。
+- 在JDK的源码实现中，可以发现最终调用的是native方法forName0()，它在JVM中调用的实际是FindClassFromCaller()，原理与ClassLoader的流程一样。
+
+```
+public static Class forName(String className)
+ throws ClassNotFoundException {
+ Class caller = Reflection.getCallerClass();
+ return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
+}
+```
+
+
+```
+private static native Class forName0(String name, boolean initialize,
+ ClassLoader loader,
+ Class caller)
+ throws ClassNotFoundException;
+```
+
+
+
+
+```
+Java_java_lang_Class_forName0(JNIEnv *env, jclass this, jstring classname,
+ jboolean initialize, jobject loader, jclass caller)
+{
+ char *clname;
+ jclass cls = 0;
+ char buf[128];
+ jsize len;
+ jsize unicode_len;
+
+ if (classname == NULL) {
+ JNU_ThrowNullPointerException(env, 0);
+ return 0;
+ }
+
+ len = (*env)->GetStringUTFLength(env, classname);
+ unicode_len = (*env)->GetStringLength(env, classname);
+ if (len >= (jsize)sizeof(buf)) {
+ clname = malloc(len + 1);
+ if (clname == NULL) {
+ JNU_ThrowOutOfMemoryError(env, NULL);
+ return NULL;
+ }
+ } else {
+ clname = buf;
+ }
+ (*env)->GetStringUTFRegion(env, classname, 0, unicode_len, clname);
+
+ if (VerifyFixClassname(clname) == JNI_TRUE) {
+ /* slashes present in clname, use name b4 translation for exception */
+ (*env)->GetStringUTFRegion(env, classname, 0, unicode_len, clname);
+ JNU_ThrowClassNotFoundException(env, clname);
+ goto done;
+ }
+
+ if (!VerifyClassname(clname, JNI_TRUE)) { /* expects slashed name */
+ JNU_ThrowClassNotFoundException(env, clname);
+ goto done;
+ }
+
+ cls = JVM_FindClassFromCaller(env, clname, initialize, loader, caller);
+
+ done:
+ if (clname != buf) {
+ free(clname);
+ }
+ return cls;
+}
+```
+
+
+
+- JVM_ENTRY(jclass, JVM_FindClassFromClass(JNIEnv *env, const char *name,
+ jboolean init, jclass from))
+ JVMWrapper2("JVM_FindClassFromClass %s", name);
+ if (name == NULL || (int)strlen(name) > Symbol::max_length()) {
+ // It's impossible to create this class; the name cannot fit
+ // into the constant pool.
+ THROW_MSG_0(vmSymbols::java_lang_NoClassDefFoundError(), name);
+ }
+ TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL);
+ oop from_class_oop = JNIHandles::resolve(from);
+ Klass* from_class = (from_class_oop == NULL)
+ ? (Klass*)NULL
+ : java_lang_Class::as_Klass(from_class_oop);
+ oop class_loader = NULL;
+ oop protection_domain = NULL;
+ if (from_class != NULL) {
+ class_loader = from_class->class_loader();
+ protection_domain = from_class->protection_domain();
+ }
+ Handle h_loader(THREAD, class_loader);
+ Handle h_prot (THREAD, protection_domain);
+ jclass result = find_class_from_class_loader(env, h_name, init, h_loader,
+ h_prot, true, thread);
+
+ if (TraceClassResolution && result != NULL) {
+ // this function is generally only used for class loading during verification.
+ ResourceMark rm;
+ oop from_mirror = JNIHandles::resolve_non_null(from);
+ Klass* from_class = java_lang_Class::as_Klass(from_mirror);
+ const char * from_name = from_class->external_name();
+
+ oop mirror = JNIHandles::resolve_non_null(result);
+ Klass* to_class = java_lang_Class::as_Klass(mirror);
+ const char * to = to_class->external_name();
+ tty->print("RESOLVE %s %s (verification)\n", from_name, to);
+ }
+
+ return result;
+JVM_END
+
+-
+
+### getDeclaredFields的实现
+- 在JDK源码中，可以知道class.getDeclaredFields()方法实际调用的是native方法getDeclaredFields0()，它在JVM主要实现步骤如下：
+ - 1)根据Class结构体信息，获取field_count与fields[]字段，这个字段早已在load过程中被放入了
+ - 2)根据field_count的大小分配内存、创建数组
+ - 3)将数组进行forEach循环，通过fields[]中的信息依次创建Object对象
+ - 4)返回数组指针
+
+- 主要慢在如下方面：
+- 创建、计算、分配数组对象
+- 对字段进行循环赋值
+
+
+```
+public Field[] getDeclaredFields() throws SecurityException {
+ checkMemberAccess(Member.DECLARED, Reflection.getCallerClass(), true);
+ return copyFields(privateGetDeclaredFields(false));
+}
+```
+
+
+
+```
+private Field[] privateGetDeclaredFields(boolean publicOnly) {
+ checkInitted();
+ Field[] res;
+ ReflectionData rd = reflectionData();
+ if (rd != null) {
+ res = publicOnly ? rd.declaredPublicFields : rd.declaredFields;
+ if (res != null) return res;
+ }
+ // No cached value available; request value from VM
+ res = Reflection.filterFields(this, getDeclaredFields0(publicOnly));
+ if (rd != null) {
+ if (publicOnly) {
+ rd.declaredPublicFields = res;
+ } else {
+ rd.declaredFields = res;
+ }
+ }
+ return res;
+}
+```
+
+
+
+```
+private static Field[] copyFields(Field[] arg) {
+ Field[] out = new Field[arg.length];
+ ReflectionFactory fact = getReflectionFactory();
+ for (int i = 0; i < arg.length; i++) {
+ out[i] = fact.copyField(arg[i]);
+ }
+ return out;
+}
+```
+
+
+-
+
+### Method.invoke的实现
+- 以下为无同步、无异常的情况下调用的步骤
+
+ - 1)创建Frame
+ - 2)如果对象flag为native，交给native_handler进行处理
+ - 3)在frame中执行java代码
+ - 4)弹出Frame
+ - 5)返回执行结果的指针
+
+- 主要慢在如下方面：
+
+- 需要完全执行ByteCode而缺少JIT等优化
+- 检查参数非常多，这些本来可以在编译器或者加载时完成
+
+
+```
+public Object invoke(Object obj, Object... args)
+ throws IllegalAccessException, IllegalArgumentException,
+ InvocationTargetException
+{
+ if (!override) {
+ if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
+ Class caller = Reflection.getCallerClass();
+ checkAccess(caller, clazz, obj, modifiers);
+ }
+ }
+ MethodAccessor ma = methodAccessor; // read volatile
+ if (ma == null) {
+ ma = acquireMethodAccessor();
+ }
+ return ma.invoke(obj, args);
+}
+```
+
+
+- NativeMethodAccessorImpl#invoke
+
+```
+public Object invoke(Object obj, Object[] args)
+ throws IllegalArgumentException, InvocationTargetException
+{
+ // We can't inflate methods belonging to vm-anonymous classes because
+ // that kind of class can't be referred to by name, hence can't be
+ // found from the generated bytecode.
+ if (++numInvocations > ReflectionFactory.inflationThreshold()
+ && !ReflectUtil.isVMAnonymousClass(method.getDeclaringClass())) {
+ MethodAccessorImpl acc = (MethodAccessorImpl)
+ new MethodAccessorGenerator().
+ generateMethod(method.getDeclaringClass(),
+ method.getName(),
+ method.getParameterTypes(),
+ method.getReturnType(),
+ method.getExceptionTypes(),
+ method.getModifiers());
+ parent.setDelegate(acc);
+ }
+
+ return invoke0(method, obj, args);
+}
+```
+
+
+
+```
+private static native Object invoke0(Method m, Object obj, Object[] args);
+```
+
+
+- Java_sun_reflect_NativeMethodAccessorImpl_invoke0
+(JNIEnv *env, jclass unused, jobject m, jobject obj, jobjectArray args)
+{
+ return JVM_InvokeMethod(env, m, obj, args);
+}
+
+
+- JVM_ENTRY(jobject, JVM_InvokeMethod(JNIEnv *env, jobject method, jobject obj, jobjectArray args0))
+ JVMWrapper("JVM_InvokeMethod");
+ Handle method_handle;
+ if (thread->stack_available((address) &method_handle) >= JVMInvokeMethodSlack) {
+ method_handle = Handle(THREAD, JNIHandles::resolve(method));
+ Handle receiver(THREAD, JNIHandles::resolve(obj));
+ objArrayHandle args(THREAD, objArrayOop(JNIHandles::resolve(args0)));
+ oop result = Reflection::invoke_method(method_handle(), receiver, args, CHECK_NULL);
+ jobject res = JNIHandles::make_local(env, result);
+ if (JvmtiExport::should_post_vm_object_alloc()) {
+ oop ret_type = java_lang_reflect_Method::return_type(method_handle());
+ assert(ret_type != NULL, "sanity check: ret_type oop must not be NULL!");
+ if (java_lang_Class::is_primitive(ret_type)) {
+ // Only for primitive type vm allocates memory for java object.
+ // See box() method.
+ JvmtiExport::post_vm_object_alloc(JavaThread::current(), result);
+ }
+ }
+ return res;
+ } else {
+ THROW_0(vmSymbols::java_lang_StackOverflowError());
+ }
+JVM_END
+
+-
+
+### class.newInstance的实现
+ - 1)检测权限、预分配空间大小等参数
+ - 2)创建Object对象，并分配空间
+ - 3)通过Method.invoke调用构造函数(())
+ - 4)返回Object指针
+
+- 主要慢在如下方面：
+
+- 参数检查不能优化或者遗漏
+- ()的查表
+- Method.invoke本身耗时
+
+```
+public T newInstance()
+ throws InstantiationException, IllegalAccessException
+{
+ if (System.getSecurityManager() != null) {
+ checkMemberAccess(Member.PUBLIC, Reflection.getCallerClass(), false);
+ }
+
+ // NOTE: the following code may not be strictly correct under
+ // the current Java memory model.
+
+ // Constructor lookup
+ if (cachedConstructor == null) {
+ if (this == Class.class) {
+ throw new IllegalAccessException(
+ "Can not call newInstance() on the Class for java.lang.Class"
+ );
+ }
+ try {
+ Class[] empty = {};
+ final Constructor c = getConstructor0(empty, Member.DECLARED);
+ // Disable accessibility checks on the constructor
+ // since we have to do the security check here anyway
+ // (the stack depth is wrong for the Constructor's
+ // security check to work)
+ java.security.AccessController.doPrivileged(
+ new java.security.PrivilegedAction() {
+ public Void run() {
+ c.setAccessible(true);
+ return null;
+ }
+ });
+ cachedConstructor = c;
+ } catch (NoSuchMethodException e) {
+ throw (InstantiationException)
+ new InstantiationException(getName()).initCause(e);
+ }
+ }
+ Constructor tmpConstructor = cachedConstructor;
+ // Security check (same as in java.lang.reflect.Constructor)
+ int modifiers = tmpConstructor.getModifiers();
+ if (!Reflection.quickCheckMemberAccess(this, modifiers)) {
+ Class caller = Reflection.getCallerClass();
+ if (newInstanceCallerCache != caller) {
+ Reflection.ensureMemberAccess(caller, this, null, modifiers);
+ newInstanceCallerCache = caller;
+ }
+ }
+ // Run constructor
+ try {
+ return tmpConstructor.newInstance((Object[])null);
+ } catch (InvocationTargetException e) {
+ Unsafe.getUnsafe().throwException(e.getTargetException());
+ // Not reached
+ return null;
+ }
+}
+```
+
+
+-
+
+# 1.19 XML
+## DOM
+- OM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的，因而DOM被认为是基于树或基于对象的。
+
+- 优点
+- ①允许应用程序对数据和结构做出更改。
+- ②访问是双向的，可以在任何时候在树中上下导航，获取和操作任意部分的数据。
+- 缺点
+- ①通常需要加载整个XML文档来构造层次结构，消耗资源大。
+
+-
+## SAX
+- SAX处理的优点非常类似于流媒体的优点。分析能够立即开始，而不是等待所有的数据被处理。而且，由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。一般来说，SAX还比它的替代者DOM快许多。
+- 优点
+- ①不需要等待所有数据都被处理，分析就能立即开始。
+- ②只在读取数据时检查数据，不需要保存在内存中。
+- ③可以在某个条件得到满足时停止解析，不必解析整个文档。
+- ④效率和性能较高，能解析大于系统内存的文档。
+
+- 缺点
+- ①需要应用程序自己负责TAG的处理逻辑（例如维护父/子关系等)，文档越复杂程序就越复杂。
+- ②单向导航，无法定位文档层次，很难同时访问同一文档的不同部分数据，不支持XPath。
+
+- JDOM
+- DOM4J
+
+-
+
+# 1.20 Java8
+## Lambda表达式&函数式接口&方法引用&Stream API
+- Java8 stream迭代的优势和区别；lambda表达式？为什么要引入它
+
+ - 1)流（高级Iterator)：对集合对象进行各种非常便利、高效的聚合操作（aggregate operation)，或者大批量数据操作 (bulk data operation)，隐式迭代等，代码简洁
+ - 2)方便地实现并行（并行流)，比如实现MapReduce
+ - 3)Lamdba：简化匿名内部类的实现，代码更加紧凑
+ - 4)方法引用：方法引用是lambda表达式的另一种表达方式
+- 对象::实例方法
+- 类::静态方法
+- 类::实例方法名
+
+## Optional
+- Optional仅仅是一个容易：存放T类型的值或者null。它提供了一些有用的接口来避免显式的null检查。
+## CompletableFuture
+ - 1)实现异步API（将任务交给另一线程完成，该线程与调用方异步，通过回调函数或阻塞的方式取得任务结果)
+ - 2)将批量同步操作转为异步操作（并行流/CompletableFuture)
+ - 3)多个异步任务合并
+## 时间日期API
+- 新的java.time包包含了所有关于日期、时间、时区、Instant（跟日期类似但是精确到纳秒)、duration（持续时间)和时钟操作的类。新设计的API认真考虑了这些类的不变性（从java.util.Calendar吸取的教训)，如果某个实例需要修改，则返回一个新的对象。
+
+## 接口中的默认方法与静态方法
+- 默认方法使得开发者可以在不破坏二进制兼容性的前提下，往现存接口中添加新的方法，即不强制那些实现了该接口的类也同时实现这个新加的方法。
+- 默认方法允许在不打破现有继承体系的基础上改进接口。该特性在官方库中的应用是：给java.util.Collection接口添加新方法，如stream()、parallelStream()、forEach()和removeIf()等等。
+
+
+-
+
+# 1.21 Java9
+## 模块化
+- 提供了类似于OSGI框架的功能，模块之间存在相互的依赖关系，可以导出一个公共的API，并且隐藏实现的细节，Java提供该功能的主要的动机在于，减少内存的开销，在JVM启动的时候，至少会有30～60MB的内存加载，主要原因是JVM需要加载rt.jar，不管其中的类是否被classloader加载，第一步整个jar都会被JVM加载到内存当中去，模块化可以根据模块的需要加载程序运行需要的class。
+- 在引入了模块系统之后，JDK 被重新组织成 94 个模块。Java 应用可以通过新增的 jlink 工具，创建出只包含所依赖的 JDK 模块的自定义运行时镜像。这样可以极大的减少 Java 运行时环境的大小。使得JDK可以在更小的设备中使用。采用模块化系统的应用程序只需要这些应用程序所需的那部分JDK模块，而非是整个JDK框架了。
+## HTTP/2
+- Java 9的版本中引入了一个新的package:java.net.http，里面提供了对Http访问很好的支持，不仅支持Http1.1而且还支持HTTP/2，以及WebSocket，据说性能特别好。
+## JShell
+- java9引入了jshell这个交互性工具，让Java也可以像脚本语言一样来运行，可以从控制台启动 jshell ，在 jshell 中直接输入表达式并查看其执行结果。当需要测试一个方法的运行效果，或是快速的对表达式进行求值时，jshell 都非常实用。
+- 除了表达式之外，还可以创建 Java 类和方法。jshell 也有基本的代码完成功能。
+## 不可变集合工厂方法
+- Java 9增加了List.of()、Set.of()、Map.of()和Map.ofEntries()等工厂方法来创建不可变集合。
+## 私有接口方法
+- Java 8 为我们提供了接口的默认方法和静态方法，接口也可以包含行为，而不仅仅是方法定义。
+- 默认方法和静态方法可以共享接口中的私有方法，因此避免了代码冗余，这也使代码更加清晰。如果私有方法是静态的，那这个方法就属于这个接口的。并且没有静态的私有方法只能被在接口中的实例调用。
+## 多版本兼容 JAR
+ - 当一个新版本的 Java 出现的时候，你的库用户要花费很长时间才会切换到这个新的版本。这就意味着库要去向后兼容你想要支持的最老的 Java 版本 (许多情况下就是 Java 6 或者 7)。这实际上意味着未来的很长一段时间，你都不能在库中运用 Java 9 所提供的新特性。幸运的是，多版本兼容 JAR 功能能让你创建仅在特定版本的 Java 环境中运行库程序时选择使用的 class 版本。
+
+## 统一 JVM 日志
+- Java 9 中 ，JVM 有了统一的日志记录系统，可以使用新的命令行选项-Xlog 来控制 JVM 上 所有组件的日志记录。该日志记录系统可以设置输出的日志消息的标签、级别、修饰符和输出目标等。
+## 垃圾收集机制
+- Java 9 移除了在 Java 8 中 被废弃的垃圾回收器配置组合，同时把G1设为默认的垃圾回收器实现。替代了之前默认使用的Parallel GC，对于这个改变，evens的评论是酱紫的：这项变更是很重要的，因为相对于Parallel来说，G1会在应用线程上做更多的事情，而Parallel几乎没有在应用线程上做任何事情，它基本上完全依赖GC线程完成所有的内存管理。这意味着切换到G1将会为应用线程带来额外的工作，从而直接影响到应用的性能
+
+## I/O 流新特性
+- java.io.InputStream 中增加了新的方法来读取和复制 InputStream 中包含的数据。
+- readAllBytes：读取 InputStream 中的所有剩余字节。
+- readNBytes： 从 InputStream 中读取指定数量的字节到数组中。
+- transferTo：读取 InputStream 中的全部字节并写入到指定的 OutputStream 中 。
+
+-
diff --git "a/docs/\344\270\203\343\200\201JavaWeb.md" "b/docs/\344\270\203\343\200\201JavaWeb.md"
new file mode 100644
index 00000000..e17dbbe8
--- /dev/null
+++ "b/docs/\344\270\203\343\200\201JavaWeb.md"
@@ -0,0 +1,4028 @@
+# JavaWeb
+# 三层模型 MVC
+- 1、MVC设计模式
+
+- MVC设计模式
+
+- MVC模式（Model-View-Controller)是软件工程中的一种软件架构模式，把软件系统分为三个基本部分：模型（Model)、视图（View)和控制器（Controller)。
+- MVC模式最早为Trygve Reenskaug提出，为施乐帕罗奥多研究中心（Xerox PARC)的Smalltalk语言发明的一种软件设计模式。
+- MVC可对程序的后期维护和扩展提供了方便，并且使程序某些部分的重用提供了方便。而且MVC也使程序简化，更加直观。
+- 控制器Controller：对请求进行处理，负责请求转发；
+- 视图View：界面设计人员进行图形界面设计；
+- 模型Model：程序编写程序应用的功能（实现算法等等)、数据库管理；
+
+- 注意，MVC不是Java的东西，几乎现在所有B/S结构的软件都采用了MVC设计模式。但是要注意，MVC在B/S结构软件并没有完全实现，例如在我们今后的B/S软件中并不会有事件驱动！
+
+- 2、JavaWeb与MVC
+- JavaWeb的经历了JSP Model1、JSP Model1二代、JSP Model2三个时期。
+- 2.1 JSP Model1第一代
+- JSP Model1是JavaWeb早期的模型，它适合小型Web项目，开发成本低！Model1第一代时期，服务器端只有JSP页面，所有的操作都在JSP页面中，连访问数据库的API也在JSP页面中完成。也就是说，所有的东西都耦合在一起，对后期的维护和扩展极为不利。
+
+
+- 2.2 JSP Model1第二代
+- JSP Model1第二代有所改进，把业务逻辑的内容放到了JavaBean中，而JSP页面负责显示以及请求调度的工作。虽然第二代比第一代好了些，但还让JSP做了过多的工作，JSP中把视图工作和请求调度（控制器)的工作耦合在一起了。
+
+
+
+- 2.3 JSP Model2
+- JSP Model2模式已经可以清晰的看到MVC完整的结构了。
+- JSP：视图层，用来与用户打交道。负责接收用来的数据，以及显示数据给用户；
+- Servlet：控制层，负责找到合适的模型对象来处理业务逻辑，转发到合适的视图；
+- JavaBean：模型层，完成具体的业务工作，例如：开启、转账等。
+
+
+- JSP Model2适合多人合作开发大型的Web项目，各司其职，互不干涉，有利于开发中的分工，有利于组件的重用。但是，Web项目的开发难度加大，同时对开发人员的技术要求也提高了。
+
+# 5.1 JavaWeb经典三层框架
+- 我们常说的三层框架是由JavaWeb提出的，也就是说这是JavaWeb独有的！
+- 所谓三层是表述层（WEB层)、业务逻辑层（Business Logic)，以及数据访问层（Data Access)。
+- WEB层：包含JSP和Servlet等与WEB相关的内容；
+- 业务层：业务层中不包含JavaWeb API，它只关心业务逻辑；
+- 数据层：封装了对数据库的访问细节；
+
+- 注意，在业务层中不能出现JavaWeb API，例如request、response等。也就是说，业务层代码是可重用的，甚至可以应用到非Web环境中。业务层的每个方法可以理解成一个万能，例如转账业务方法。业务层依赖数据层，而Web层依赖业务层！
+
+
+
+# Web服务器
+- Web服务器的作用是接收客户端的请求，给客户端作出响应。
+- 对于JavaWeb程序而已，还需要有Servlet容器，Servlet容器的基本功能是把动态资源转换成静态资源。
+- 我们需要使用的是Web服务器和Servlet容器，通常这两者会集于一身。下面是对JavaWeb服务器：
+- Tomcat（Apache)：当前应用最广的JavaWeb服务器；
+- JBoss（Redhat红帽)：支持JavaEE，应用比较广；EJB容器
+- GlassFish（Orcale)：Oracle开发JavaWeb服务器，应用不是很广；
+- Resin（Caucho)：支持JavaEE，应用越来越广；
+- Weblogic（Oracle)：收费；支持JavaEE，适合大型项目；
+- Websphere（IBM)：收费；支持JavaEE，适合大型项目；
+
+- 支持JavaEE是EJB容器
+
+# Servlet
+# 5.2 定义
+- Servlet是JavaWeb的三大组件之一，它属于动态资源。Servlet的作用是处理请求，服务器会把接收到的请求交给Servlet来处理，在Servlet中通常需要：
+- 接收请求数据；
+- 处理请求；
+- 完成响应。
+- 例如客户端发出登录请求，或者输出注册请求，这些请求都应该由Servlet来完成处理！Servlet需要我们自己来编写，每个Servlet必须实现javax.servlet.Servlet接口。
+# 5.3 生命周期
+- 生命周期方法：
+- void init(ServletConfig)：出生之后（1次)；
+- void service(ServletRequest request, ServletResponse response)：每次处理请求时都会被调用；
+- void destroy()：临死之前（1次)；
+
+- 特性：
+- 单例，一个类只有一个对象；当然可能存在多个Servlet类！
+- 多线程的，所以它的效率是高的！（不是线程安全的)
+
+- Servlet类由我们来写，但对象由服务器来创建，并且由服务器来调用相应的方法。
+## Servlet的出生
+- 服务器会在Servlet第一次被访问时创建Servlet，或者是在服务器启动时创建Servlet。如果服务器启动时就创建Servlet，那么还需要在web.xml文件中配置。也就是说默认情况下，Servlet是在第一次被访问时由服务器创建的。
+- 而且一个Servlet类型，服务器只创建一个实例对象，例如在我们首次访问http://localhost:8080/helloservlet/helloworld时，服务器通过“/helloworld”找到了绑定的Servlet名称为cn.itcast.servlet.HelloServlet，然后服务器查看这个类型的Servlet是否已经创建过，如果没有创建过，那么服务器才会通过反射来创建HelloServlet的实例。当我们再次访问http://localhost:8080/helloservlet/helloworld时，服务器就不会再次创建HelloServlet实例了，而是直接使用上次创建的实例。
+- 在Servlet被创建后，服务器会马上调用Servlet的void init(ServletConfig)方法。请记住， Servlet出生后马上就会调用init()方法，而且一个Servlet的一生。这个方法只会被调用一次。
+- 我们可以把一些对Servlet的初始化工作放到init方法中！
+## Servlet服务
+- 当服务器每次接收到请求时，都会去调用Servlet的service()方法来处理请求。服务器接收到一次请求，就会调用service() 方法一次，所以service()方法是会被调用多次的。正因为如此，所以我们才需要把处理请求的代码写到service()方法中！
+## Servlet的销毁
+- Servlet是不会轻易离去的，通常都是在服务器关闭时Servlet才会离去！在服务器被关闭时，服务器会去销毁Servlet，在销毁Servlet之前服务器会先去调用Servlet的destroy()方法，我们可以把Servlet的临终遗言放到destroy()方法中，例如对某些资源的释放等代码放到destroy()方法中。
+- Servlet接口相关类型
+- 在Servlet接口中还存在三个我们不熟悉的类型：
+- ServletRequest：service() 方法的参数，它表示请求对象，它封装了所有与请求相关的数据，它是由服务器创建的；
+- ServletResponse：service()方法的参数，它表示响应对象，在service()方法中完成对客户端的响应需要使用这个对象；
+- ServletConfig：init()方法的参数，它表示Servlet配置对象，它对应Servlet的配置
+- ServletRequest和ServletResponse
+- ServletRequest和ServletResponse是Servlet#service() 方法的两个参数，一个是请求对象，一个是响应对象，可以从ServletRequest对象中获取请求数据，可以使用ServletResponse对象完成响应。
+- ServletRequest和ServletResponse的实例由服务器创建，然后传递给service()方法。如果在service() 方法中希望使用HTTP相关的功能，那么可以把ServletRequest和ServletResponse强转成HttpServletRequest和HttpServletResponse。这也说明我们经常需要在service()方法中对ServletRequest和ServletResponse进行强转，这是很心烦的事情。不过后面会有一个类来帮我们解决这一问题的。
+- HttpServletRequest方法：
+- String getParameter(String paramName)：获取指定请求参数的值；
+- String getMethod()：获取请求方法，例如GET或POST；
+- String getHeader(String name)：获取指定请求头的值；
+- void setCharacterEncoding(String encoding)：设置请求体的编码！
+- 因为GET请求没有请求体，所以这个方法只对POST请求有效。当调用
+- request.setCharacterEncoding(“utf-8”)之后，再通过getParameter()方法获取参数值时，那么参数值都已经通过了转码，即转换成了UTF-8编码。所以，这个方法必须在调用getParameter()方法之前调用！
+- HttpServletResponse方法：
+- PrintWriter getWriter()：获取字符响应流，使用该流可以向客户端输出响应信息。例如response.getWriter().print(“Hello JavaWeb!
”)；
+- ServletOutputStream getOutputStream()：获取字节响应流，当需要向客户端响应字节数据时，需要使用这个流，例如要向客户端响应图片；
+- void setCharacterEncoding(String encoding)：用来设置字符响应流的编码，例如在调用setCharacterEncoding(“utf-8”);之后，再response.getWriter()获取字符响应流对象，这时的响应流的编码为utf-8，使用response.getWriter()输出的中文都会转换成utf-8编码后发送给客户端；
+- void setHeader(String name, String value)：向客户端添加响应头信息，
+- 例如setHeader(“Refresh”, “3;url=http://www.itcast.cn”)，表示3秒后自动刷新到http://www.itcast.cn；
+- void setContentType(String contentType)：该方法是setHeader(“content-type”, “xxx”)的简便方法，即用来添加名为content-type响应头的方法。content-type响应头用来设置响应数据的MIME类型，例如要向客户端响应jpg的图片，那么可以setContentType(“image/jepg”)，如果响应数据为文本类型，那么还要同时设置编码，例如setContentType(“text/html;chartset=utf-8”)表示响应数据类型为文本类型中的html类型，并且该方法会调用setCharacterEncoding(“utf-8”)方法；
+- void sendError(int code, String errorMsg)：向客户端发送状态码，以及错误消息。例如给客户端发送404：response(404, “您要查找的资源不存在！”)。
+-
+
+- ServletConfig
+- Servlet的配置信息，即web.xml文件中的元素。
+- 一个ServletConfig对象对应着一个servlet元素的配置信息（servlet-name，servlet-class)
+
+
+- getServletName获取的是的功能
+- getServletContext获取的是Servlet上下文对象
+
+- ServletConfig对象对应web.xml文件中的元素。例如你想获取当前Servlet在web.xml文件中的配置名，那么可以使用servletConfig.getServletName()方法获取！
+
+- ServletConfig对象是由服务器创建的，然后传递给Servlet的init()方法，你可以在init()方法中使用它！
+- String getServletName()：获取Servlet在web.xml文件中的配置名称，即指定的名称；
+- ServletContext getServletContext()：用来获取ServletContext对象；
+- String getInitParameter(String name)：用来获取在web.xml中配置的初始化参数，通过参数名来获取参数值；
+- Enumeration getInitParameterNames()：用来获取在web.xml中配置的所有初始化参数名称；
+- 在元素中还可以配置初始化参数：
+
+ One
+ cn.itcast.servlet.OneServlet
+
+ paramName1
+ paramValue1
+
+
+ paramName2
+ paramValue2
+
+
+
+- 在OneServlet中，可以使用ServletConfig对象的getInitParameter()方法来获取初始化参数，例如：
+- String value1 = servletConfig.getInitParameter(“paramName1”);//获取到paramValue1
+# 5.4 实现Servlet的方式
+- 实现Servlet有三种方式：
+- 实现javax.servlet.Servlet接口；
+- 继承javax.servlet.GenericServlet类；
+- 继承javax.servlet.http.HttpServlet类；
+- 通常我们会去继承HttpServlet类来完成我们的Servlet
+- GenericServlet
+- GenericServlet概述
+
+- GenericServlet是Servlet接口的实现类，我们可以通过继承GenericServlet来编写自己的Servlet。下面是GenericServlet类的源代码：
+- GenericServlet.java
+public abstract class GenericServlet implements Servlet, ServletConfig,
+ java.io.Serializable {
+ private static final long serialVersionUID = 1L;
+ private transient ServletConfig config;
+ public GenericServlet() {}
+ @Override
+ public void destroy() {}
+ @Override
+ public String getInitParameter(String name) {
+ return getServletConfig().getInitParameter(name);
+ }
+ @Override
+ public Enumeration getInitParameterNames() {
+ return getServletConfig().getInitParameterNames();
+ }
+ @Override
+ public ServletConfig getServletConfig() {
+ return config;
+ }
+ @Override
+ public ServletContext getServletContext() {
+ return getServletConfig().getServletContext();
+ }
+ @Override
+ public String getServletInfo() {
+ return "";
+ }
+ @Override
+ public void init(ServletConfig config) throws ServletException {
+ this.config = config;
+ this.init();
+ }
+public void init() throws ServletException {}
+这个init方法是为了拓展init而设置的，子类可以重写这个无参数的init方法
+ public void log(String msg) {
+ getServletContext().log(getServletName() + ": " + msg);
+ }
+ public void log(String message, Throwable t) {
+ getServletContext().log(getServletName() + ": " + message, t);
+ }
+ @Override
+ public abstract void service(ServletRequest req, ServletResponse res)
+ throws ServletException, IOException;
+ @Override
+ public String getServletName() {
+ return config.getServletName();
+ }
+}
+
+- GenericServlet的init()方法
+- 在GenericServlet中，定义了一个ServletConfig实例变量，并在init(ServletConfig)方法中把参数ServletConfig赋给了实例变量。然后在该类的很多方法中使用了实例变量config。
+- 如果子类覆盖了GenericServlet的init(StringConfig)方法，那么this.config=config这一条语句就会被覆盖了，也就是说GenericServlet的实例变量config的值为null，那么所有依赖config的方法都不能使用了。如果真的希望完成一些初始化操作，那么去覆盖GenericServlet提供的init()方法，它是没有参数的init()方法，它会在init(ServletConfig)方法中被调用。
+- 实现了ServletConfig接口
+- GenericServlet还实现了ServletConfig接口，所以可以直接调用getInitParameter()、getServletContext()等ServletConfig的方法。
+
+- HttpServlet
+- HttpServlet概述
+- HttpServlet类是GenericServlet的子类，它提供了对HTTP请求的特殊支持，所以通常我们都会通过继承HttpServlet来完成自定义的Servlet。
+- HttpServlet覆盖了service()方法
+- HttpServlet类中提供了service(HttpServletRequest,HttpServletResponse)方法，这个方法是HttpServlet自己的方法，不是从Servlet继承来的。在HttpServlet的service(ServletRequest,ServletResponse)方法中会把ServletRequest和ServletResponse强转成HttpServletRequest和HttpServletResponse，然后调用
+- service(HttpServletRequest,HttpServletResponse)方法，这说明子类可以去覆盖service(HttpServletRequest,HttpServletResponse)方法即可，这就不用自己去强转请求和响应对象了。
+- 其实子类也不用去覆盖service(HttpServletRequest,HttpServletResponse)方法，因为HttpServlet还要做另一步简化操作，下面会介绍。
+
+- HttpServlet.java
+public abstract class HttpServlet extends GenericServlet {
+ protected void service(HttpServletRequest req, HttpServletResponse resp)
+ throws ServletException, IOException {
+ ……
+}
+ @Override
+ public void service(ServletRequest req, ServletResponse res)
+ throws ServletException, IOException {
+
+ HttpServletRequest request;
+ HttpServletResponse response;
+
+ try {
+ request = (HttpServletRequest) req;
+ response = (HttpServletResponse) res;
+ } catch (ClassCastException e) {
+ throw new ServletException("non-HTTP request or response");
+ }
+ service(request, response);
+}
+……
+}
+- doGet()和doPost()
+- 在HttpServlet的service(HttpServletRequest,HttpServletResponse)方法会去判断当前请求是GET还是POST，如果是GET请求，那么会去调用本类的doGet()方法，如果是POST请求会去调用doPost()方法，这说明我们在子类中去覆盖doGet()或doPost()方法即可。
+public class AServlet extends HttpServlet {
+ public void doGet(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ System.out.println("hello doGet()...");
+ }
+}
+public class BServlet extends HttpServlet {
+ public void doPost(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ System.out.println("hello doPost()...");
+ }
+}
+
+- Servlet细节
+- 不要在Servlet中创建成员！创建局部变量即可！
+- 可以创建无状态成员！
+- 可以创建有状态的成员，但状态必须为只读的！（只有get，没有set)
+- Servlet与线程安全
+- 因为一个类型的Servlet只有一个实例对象，那么就有可能会现时出一个Servlet同时处理多个请求，那么Servlet是否为线程安全的呢？答案是：“不是线程安全的”。这说明Servlet的工作效率很高，但也存在线程安全问题！
+- 所以我们不应该在Servlet中创建成员变量，因为可能会存在一个线程对这个成员变量进行写操作，另一个线程对这个成员变量进行读操作。
+
+- 让服务器在启动时就创建Servlet（很少这么做)
+- 默认情况下，服务器会在某个Servlet第一次收到请求时创建它。也可以在web.xml中对Servlet进行配置，使服务器启动时就创建Servlet。
+
+ hello1
+ cn.itcast.servlet.Hello1Servlet
+ 0
+
+
+ hello1
+ /hello1
+
+
+ hello2
+ cn.itcast.servlet.Hello2Servlet
+ 1
+
+
+ hello2
+ /hello2
+
+
+ hello3
+ cn.itcast.servlet.Hello3Servlet
+ 2
+
+
+ hello3
+ /hello3
+
+
+- 在元素中配置元素可以让服务器在启动时就创建该Servlet，其中元素的值必须是大于等于的整数，它的使用是服务器启动时创建Servlet的顺序。上例中，根据的值可以得知服务器创建Servlet的顺序为Hello1Servlet、Hello2Servlet、Hello3Servlet。
+-
+- 是的子元素，用来指定Servlet的访问路径，即URL。
+- 它必须是以“/”开头！
+1)- 可以在中给出多个，例如：
+
+ AServlet
+ /AServlet
+ /BServlet
+
+
+- 那么这说明一个Servlet绑定了两个URL，无论访问/AServlet还是/BServlet，访问的都是AServlet。
+
+2)- 还可以在中使用通配符，所谓通配符就是星号“*”，星号可以匹配任何URL前缀或后缀，使用通配符可以命名一个Servlet绑定一组URL，例如：
+
+```
+/servlet/*：/servlet/a、/servlet/b，都匹配/servlet/*；
+```
+
+- *.do：/abc/def/ghi.do、/a.do，都匹配*.do；
+
+```
+/*：匹配所有URL；
+```
+
+
+
+```
+请注意，通配符要么为前缀，要么为后缀，不能出现在URL中间位置，也不能只有通配符。例如：/*.do就是错误的，因为星号出现在URL的中间位置上了。*.*也是不对的，因为一个URL中最多只能出现一个通配符。
+```
+
+- 注意，通配符是一种模糊匹配URL的方式，如果存在更具体的，那么访问路径会去匹配具体的。例如：
+
+ hello1
+ cn.itcast.servlet.Hello1Servlet
+
+
+ hello1
+ /servlet/hello1
+
+
+ hello2
+ cn.itcast.servlet.Hello2Servlet
+
+
+ hello2
+ /servlet/*
+
+
+- 当访问路径为http://localhost:8080/hello/servlet/hello1时，因为访问路径即匹配hello1的，又匹配hello2的，但因为hello1的中没有通配符，所以优先匹配，即设置hello1。
+- web.xml文件的继承
+- 在${CATALINA_HOME}\conf\web.xml中的内容，相当于写到了每个项目的web.xml中，它是所有web.xml的父文件。
+- 每个完整的JavaWeb应用中都需要有web.xml，但我们不知道所有的web.xml文件都有一个共同的父文件，它在Tomcat的conf/web.xml路径。
+- conf/web.xml
+
+
+
+
+ default
+ org.apache.catalina.servlets.DefaultServlet
+
+ debug
+ 0
+
+
+ listings
+ false
+
+ 1
+
+
+
+ jsp
+ org.apache.jasper.servlet.JspServlet
+
+ fork
+ false
+
+
+ xpoweredBy
+ false
+
+ 3
+
+
+
+ default
+ /
+
+
+
+ jsp
+ *.jsp
+ *.jspx
+
+
+
+ 30
+
+
+
+
+ bmp
+ image/bmp
+
+
+ htm
+ text/html
+
+
+
+ index.html
+ index.htm
+ index.jsp
+
+
+
+- ServletContext（存取数据，获取资源)
+- 一个项目只有一个ServletContext对象！
+- 我们可以在N多个Servlet中来获取这个唯一的对象，使用它可以给多个Servlet传递数据！
+- 这个对象在Tomcat启动时就创建，在Tomcat关闭时才会死去！
+- ServletContext概述
+- 服务器会为每个应用创建一个ServletContext对象：
+- ServletContext对象的创建是在服务器启动时完成的；
+- ServletContext对象的销毁是在服务器关闭时完成的。
+
+- ServletContext对象的作用是在整个Web应用的动态资源之间共享数据！例如在AServlet中向ServletContext对象中保存一个值，然后在BServlet中就可以获取这个值，这就是共享数据了。
+
+- 获取ServletContext
+- ServletConfig#getServletContext()；
+- GenericServlet#getServletContext();
+- HttpSession#getServletContext()
+- ServletContextEvent#getServletContext()
+
+
+- 在Servlet中获取ServletContext对象：
+- 在void init(ServletConfig config)中：ServletContext context = config.getServletContext();，ServletConfig类的getServletContext()方法可以用来获取ServletContext对象；
+- 在GenericeServlet或HttpServlet中获取ServletContext对象：
+- GenericServlet类有getServletContext()方法，所以可以直接使用
+- this.getServletContext()来获取；
+-
+public class MyServlet implements Servlet {
+public void init(ServletConfig config) {
+ ServletContext context = config.getServletContext();
+}
+…
+}
+public class MyServlet extends HttpServlet {
+public void doGet(HttpServletRequest request, HttpServletResponse response) {
+ ServletContext context = this.getServletContext();
+}
+}
+- 域对象的功能
+- ServletContext是JavaWeb四大域对象之一：
+- PageContext；
+- ServletRequest；
+- HttpSession；
+- ServletContext；
+
+- 所有域对象都有存取数据的功能，因为域对象内部有一个Map，用来存储数据，下面是ServletContext对象用来操作数据的方法：
+- void setAttribute(String name, Object value)：用来存储一个对象，也可以称之为存储一个域属性，例如：servletContext.setAttribute(“xxx”, “XXX”)，在ServletContext中保存了一个域属性，域属性名称为xxx，域属性的值为XXX。请注意，如果多次调用该方法，并且使用相同的name，那么会覆盖上一次的值，这一特性与Map相同；
+- Object getAttribute(String name)：用来获取ServletContext中的数据，当前在获取之前需要先去存储才行，例如：String value = (String)servletContext.getAttribute(“xxx”);，获取名为xxx的域属性；
+- void removeAttribute(String name)：用来移除ServletContext中的域属性，如果参数name指定的域属性不存在，那么本方法什么都不做；
+- Enumeration getAttributeNames()：获取所有域属性的名称；
+- 获取应用初始化参数
+- Servlet也可以获取初始化参数，但它是局部的参数；也就是说，一个Servlet只能获取自己的初始化参数，不能获取别人的，即初始化参数只为一个Servlet准备！
+- 可以配置公共的初始化参数，为所有Servlet而用！这需要使用ServletContext才能使用！
+- 还可以使用ServletContext来获取在web.xml文件中配置的应用初始化参数！注意，应用初始化参数与Servlet初始化参数不同：
+- web.xml
+
+ ...
+ （为ServletContext设置的公共初始化参数)
+ paramName1
+ paramValue1
+
+
+ paramName2
+ paramValue2
+
+
+ ServletContext context = this.getServletContext();
+ String value1 = context.getInitParameter("paramName1");
+ String value2 = context.getInitParameter("paramName2");
+ System.out.println(value1 + ", " + value2);
+
+ Enumeration names = context.getInitParameterNames();
+ while(names.hasMoreElements()) {
+ System.out.println(names.nextElement());
+ }
+
+# 5.5 请求&响应
+
+- 服务器每次收到请求时，都会为这个请求开辟一个新的线程。
+- Response
+- 1、概述
+- response是Servlet#service方法的一个参数，类型为
+- javax.servlet.http.HttpServletResponse。在客户端发出每个请求时，服务器都会创建一个response对象，并传入给Servlet.service()方法。response对象是用来对客户端进行响应的，这说明在service()方法中使用response对象可以完成对客户端的响应工作。
+- response对象的功能分为以下四种：
+- 设置响应头信息；
+- 发送状态码；
+- 设置响应正文；
+- 重定向。
+- 2、响应正文
+- response是响应对象，向客户端输出响应正文（响应体)可以使用response的响应流，repsonse一共提供了两个响应流对象：
+- PrintWriter out = response.getWriter()：获取字符流；
+- ServletOutputStream out = response.getOutputStream()：获取字节流；
+- 当然，如果响应正文内容为字符（html)，那么使用response.getWriter()，如果响应内容是字节（图片等)，例如下载时，那么可以使用response.getOutputStream()
+- (ServletOutputStream)。
+- 注意，在一个请求中，不能同时使用这两个流！也就是说，要么你使用repsonse.getWriter()，要么使用response.getOutputStream()，但不能同时使用这两个流。不然会抛出IllegalStateException异常。
+- 字符响应流
+- 字符编码
+- 在使用response.getWriter()时需要注意默认字符编码为ISO-8859-1，如果希望设置字符流的字符编码为utf-8，可以使用response.setCharaceterEncoding(“utf-8”)来设置。这样可以保证输出给客户端的字符都是使用UTF-8编码的！
+- 但客户端浏览器并不知道响应数据是什么编码的！如果希望通知客户端使用UTF-8来解读响应数据，那么还是使用response.setContentType("text/html;charset=utf-8")方法比较好，因为这个方法不只会调用response.setCharaceterEncoding(“utf-8”)，还会设置content-type响应头，客户端浏览器会使用content-type头来解读响应数据。
+- 缓冲区
+- response.getWriter()是PrintWriter类型，所以它有缓冲区，缓冲区的默认大小为8KB。也就是说，在响应数据没有输出8KB之前，数据都是存放在缓冲区中，而不会立刻发送到客户端。当Servlet执行结束后，服务器才会去刷新流，使缓冲区中的数据发送到客户端。
+- 如果希望响应数据马上发送给客户端：
+- 向流中写入大于8KB的数据；
+- 调用response.flushBuffer()方法来手动刷新缓冲区；
+- 字节响应流
+- 将一张图片转为字节流写入到response中
+
+- 读取图片，使用commons-io包的方法。
+- byte[] image = IOUtils.toByteArray(new FileInputStream(this.getServletContext().getRealPath("/images/cat.jpeg")));
+- response.getOutputStream().write(image);
+
+- 3、设置响应头信息
+- 响应头是键值对
+- 可以使用response对象的setHeader()方法来设置响应头！使用该方法设置的响应头最终会发送给客户端浏览器！
+- response.setHeader(“content-type”, “text/html;charset=utf-8”)：设置content-type响应头，该头的作用是告诉浏览器响应内容为html类型，编码为utf-8。而且同时会设置response的字符流编码为utf-8，即response.setCharaceterEncoding(“utf-8”)；
+- response.setHeader("Refresh","5; URL=http://www.itcast.cn")：5秒后自动跳转到传智主页。
+
+- 4、设置状态码及其他方法
+- response.setContentType("text/html;charset=utf-8")：等同\于调用
+- response.setHeader(“content-type”, “text/html;charset=utf-8”)；
+- response.setCharacterEncoding(“utf-8”)：设置字符响应流的字符编码为utf-8；
+- response.setStatus(200)：设置状态码；
+- response.sendError(404, “您要查找的资源不存在”)：当发送错误状态码时，Tomcat会跳转到固定的错误页面去，但可以显示错误信息。
+- response.sendError(状态码)
+- 5、重定向
+ - 1)什么是重定向
+- 当你访问http://www.sun.com时，你会发现浏览器地址栏中的URL会变成http://www.oracle.com/us/sun/index.htm，这就是重定向了。
+- 重定向是服务器通知浏览器去访问另一个地址，即再发出另一个请求。
+
+ - 2)完成重定向
+- 响应码为200表示响应成功，而响应码为302表示重定向。所以完成重定向的第一步就是设置响应码为302。
+- 因为重定向是通知浏览器发出第二个请求，所以浏览器需要知道第二个请求的URL，所以完成重定向的第二步是设置Location头，指定第二个请求的URL地址。
+
+public class AServlet extends HttpServlet {
+ public void doGet(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ response.setStatus(302);
+ response.setHeader("Location", "http://www.itcast.cn");
+ }
+}
+
+- 上面代码的作用是：当访问AServlet后，会通知浏览器重定向到传智主页。客户端浏览器解析到响应码为302后，就知道服务器让它重定向，所以它会马上获取响应头Location，然发出第二个请求。
+
+ - 3)便捷的重定向方式sendRedirect
+public class AServlet extends HttpServlet {
+ public void doGet(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ response.sendRedirect("http://www.itcast.cn");
+ }
+}
+- response.sendRedirect()方法会设置响应头为302，以设置Location响应头。
+- 如果要重定向的URL是在同一个服务器内，那么可以使用相对路径，例如：
+public class AServlet extends HttpServlet {
+ public void doGet(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ response.sendRedirect("/hello/BServlet");
+ 注意是/项目名/路径（请求URI)
+ }
+}
+- 重定向的URL地址为：http://localhost:8080/hello/BServlet
+ - 4)重定向小结
+- 重定向是两次请求；
+- 重定向的URL可以是其他应用，不局限于当前应用；
+- 重定向的响应头为302，并且必须要有Location响应头；
+- 重定向就不要再使用response.getWriter()或response.getOutputStream()输出数据，不然可能会出现异常；
+-
+
+- Request
+- 1、概述
+- request是Servlet.service()方法的一个参数，类型为javax.servlet.http.HttpServletRequest。在客户端发出每个请求时，服务器都会创建一个request对象，并把请求数据封装到request中，然后在调用Servlet.service()方法时传递给service()方法，这说明在service()方法中可以通过request对象来获取请求数据。
+
+- request的功能可以分为以下几种：
+- 封装了请求头数据；
+- 封装了请求正文数据，如果是GET请求，那么就没有正文；
+- request是一个域对象，可以把它当成Map来添加获取数据；
+- request提供了请求转发和请求包含功能。
+- 2、域方法
+- request是域对象！在JavaWeb中一共四个域对象，其中ServletContext就是域对象，它在整个应用中只创建一个ServletContext对象。request其中一个，request可以在一个请求中共享数据。
+- 一个请求会创建一个request对象，如果在一个请求中经历了多个Servlet，那么多个Servlet就可以使用request来共享数据。
+- 下面是request的域方法：
+- void setAttribute(String name, Object value)：用来存储一个对象，也可以称之为存储一个域属性，例如：servletContext.setAttribute(“xxx”, “XXX”)，在request中保存了一个域属性，域属性名称为xxx，域属性的值为XXX。请注意，如果多次调用该方法，并且使用相同的name，那么会覆盖上一次的值，这一特性与Map相同；
+- Object getAttribute(String name)：用来获取request中的数据，当前在获取之前需要先去存储才行，例如：String value = (String)request.getAttribute(“xxx”);，获取名为xxx的域属性；
+- void removeAttribute(String name)：用来移除request中的域属性，如果参数name指定的域属性不存在，那么本方法什么都不做；
+- Enumeration getAttributeNames()：获取所有域属性的名称；
+
+- 3、获取请求头数据
+- request与请求头相关的方法有：
+- String getHeader(String name)：获取指定名称的请求头；
+- Enumeration getHeaderNames()：获取多值头；
+- int getIntHeader(String name)：获取值为int类型的请求头。
+- long getDateHeader(String name)：获取值为long类型的请求头
+
+- 4、获取请求相关的其它方法
+- request中还提供了与请求相关的其他方法，有些方法是为了我们更加便捷的方法请求头数据而设计，有些是与请求URL相关的方法。
+- int getContentLength()：获取请求体的字节数，GET请求没有请求体，没有请求体返回-1；
+- String getContentType()：获取请求类型，如果请求是GET，那么这个方法返回null；如果是POST请求，那么默认为application/x-www-form-urlencoded，表示请求体内容使用了URL编码；
+- String getMethod()：返回请求方法，例如：GET/POST
+- Locale getLocale()：返回当前客户端浏览器的Locale。java.util.Locale表示国家和言语，这个东西在国际化中很有用；
+- String getCharacterEncoding()：获取请求编码，如果没有setCharacterEncoding()，那么返回null，表示使用ISO-8859-1编码；
+- void setCharacterEncoding(String code)：设置请求编码，只对请求体有效！注意，对于GET而言，没有请求体！！！所以此方法只能对POST请求中的参数有效！
+- String getContextPath()：返回上下文路径（/项目名)，例如：/hello
+- String getQueryString()：返回请求URL中的参数，例如：name=zhangSan
+- String getRequestURI()：返回请求URI路径，例如：/hello/oneServlet
+- StringBuffer getRequestURL()：返回请求URL路径，例如：
+- http://localhost/hello/oneServlet，即返回除了参数以外的路径信息；
+- String getServletPath()：返回Servlet路径，例如：/oneServlet
+- String getRemoteAddr()：返回当前客户端的IP地址；
+- String getRemoteHost()：返回当前客户端的主机名，但这个方法的实现还是获取IP地址；
+- String getScheme()：返回请求协议，例如：http；
+- String getServerName()：返回主机名，例如：localhost
+- int getServerPort()：返回服务器端口号，例如：8080
+
+- System.out.println("IP:"+request.getRemoteAddr());
+- System.out.println("请求方式:"+request.getMethod());
+- System.out.println("User-Agent请求头:"+request.getHeader("User-Agent"));
+- System.out.println("协议名:"+request.getScheme());
+- System.out.println("主机名:"+request.getServerName());
+- System.out.println("端口号:"+request.getServerPort());
+- System.out.println("项目:"+request.getContextPath());
+- System.out.println("Servlet路径:"+request.getServletPath());
+- System.out.println("请求参数:"+request.getQueryString());
+- System.out.println("URI:"+request.getRequestURI());
+- System.out.println("URL:"+request.getRequestURL());
+- =========================================================================
+- http://localhost:8080/Request&Response/RequestHeaderServlet?username=sxj&password=sxj
+- ==========================================================================
+- IP:127.0.0.1
+- 请求方式:GET
+ - User-Agent请求头:Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36
+- 协议名:http
+- 主机名:localhost
+- 端口号:8080
+- 项目:/Request&Response
+- Servlet路径:/RequestHeaderServlet
+- 请求参数: username=sxj&password=sxj
+- URI:/Request&Response/RequestHeaderServlet（RequestURI)
+- URL:http://localhost:8080/Request&Response/RequestHeaderServlet
+- 整个访问的路径就等于URL+QueryString
+- URL=协议名+主机名+端口号+URI
+- 案例：request.getRemoteAddr()：封IP
+- 可以使用request.getRemoteAddr()方法获取客户端的IP地址，然后判断IP是否为禁用IP。
+ String ip = request.getRemoteAddr();
+ System.out.println(ip);
+ if(ip.equals("127.0.0.1")) {
+ response.getWriter().print("您的IP已被禁止！");
+ } else {
+ response.getWriter().print("Hello!");
+ }
+- 案例：防盗链
+- 可以使用request.getAttribute(“Referer”)如果不是当前页面，那么属于盗链，则跳转到当前页面
+- 如果是从地址栏直接输入URL，那么Referee返回的是null
+- String referer = request.getHeader("Referer");
+- System.out.println(referer);
+- if(referer == null || !referer.contains("localhost")){
+- response.sendRedirect("http://www.baidu.com");
+- }else{
+- response.getWriter().print("hello");//如果是从指定页面跳转来的
+- }
+
+- 5、获取请求参数
+- 最为常见的客户端传递参数方式有两种：
+- 浏览器地址栏直接输入：一定是GET请求；
+- 超链接：一定是GET请求；
+- 表单：可以是GET，也可以是POST，这取决与
+
+
+- 下面是使用request获取请求参数的API：
+- String getParameter(String name)：通过指定名称获取参数值；
+
+ public void doGet(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ String v1 = request.getParameter("p1");
+ String v2 = request.getParameter("p2");
+ System.out.println("p1=" + v1);
+ System.out.println("p2=" + v2);
+ }
+
+ public void doPost(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ String v1 = request.getParameter("p1");
+ String v2 = request.getParameter("p2");
+ System.out.println("p1=" + v1);
+ System.out.println("p2=" + v2);
+ }
+
+- String[] getParameterValues(String name)：当多个参数名称相同时，可以使用方法来获取；
+超链接
+ public void doGet(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ String[] names = request.getParameterValues("name");
+ System.out.println(Arrays.toString(names));
+ }
+- Enumeration getParameterNames()：获取所有参数的名字；
+
+ public void doPost(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ Enumeration names = request.getParameterNames();
+ while(names.hasMoreElements()) {
+ System.out.println(names.nextElement());
+ }
+ }
+
+- Map getParameterMap()：获取所有参数封装到Map中，其中key为参数名，value为参数值，因为一个参数名称可能有多个值，所以参数值是String[]，而不是String。
+超链接
+ Map paramMap = request.getParameterMap();
+ for(String name : paramMap.keySet()) {
+ String[] values = paramMap.get(name);
+ System.out.println(name + ": " + Arrays.toString(values));
+ }
+p2: [v2, vv2]
+p1: [v1, vv1]
+
+- 示例：
+
+-
+- 点击这里，测试GET请求
+-
+-
+
+- //遍历Map
+
+```
+public class RequestParameterServlet extends HttpServlet {
+```
+
+
+```
+ public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+```
+
+- Enumeration names = request.getParameterNames();
+- while(names.hasMoreElements()){
+- String name = names.nextElement();
+- System.out.println(name+"="+request.getParameter(name));
+- }
+- }
+
+-
+
+```
+ public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
+```
+
+- Map map = request.getParameterMap();
+- for(Entry entry:map.entrySet()){
+- System.out.println(entry.getKey()+"="+Arrays.toString(entry.getValue()));
+- }
+-
+- }
+- }
+
+- username=sxj
+- password=sxj
+- username=[23]
+- password=[123]
+- hobby=[eat, sleep]
+- String username = request.getParameter("username");
+- String password = request.getParameter("password");
+- String [] hobbies = request.getParameterValues("hobby");
+- System.out.println("username:"+username);
+- System.out.println("password:"+password);
+- System.out.println("hobbies:"+Arrays.toString(hobbies));
+- 6、请求转发和请求包含
+- 无论是请求转发还是请求包含，都表示由多个Servlet共同来处理一个请求。例如Servlet1来处理请求，然后Servlet1又转发给Servlet2来继续处理这个请求。
+
+ - 1)请求转发（常用)
+- 在AServlet中，把请求转发到BServlet：
+- 参数是Servlet路径（servlet-mapping中的url-pattern)
+- 相当于/项目名
+public class AServlet extends HttpServlet {
+ public void doGet(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ System.out.println("AServlet");
+ RequestDispatcher rd = request.getRequestDispatcher("/BServlet");
+ rd.forward(request, response);
+ }
+}
+public class BServlet extends HttpServlet {
+ public void doGet(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ System.out.println("BServlet");
+ }
+}
+Aservlet
+BServlet
+- 如果转发了，那么在原本请求的Servlet中设置的响应体是失效的。
+- 如果转发前，在原本请求的Servlet中设置的响应体超过24K，那么响应体仍有效（缓冲区溢出)。
+ - 2)请求包含（不常用)
+- 在AServlet中，把请求包含到BServlet：
+public class AServlet extends HttpServlet {
+ public void doGet(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ System.out.println("AServlet");
+ RequestDispatcher rd = request.getRequestDispatcher("/BServlet");
+ rd.include(request, response);
+ }
+}
+public class BServlet extends HttpServlet {
+ public void doGet(HttpServletRequest request, HttpServletResponse response)
+ throws ServletException, IOException {
+ System.out.println("BServlet");
+ }
+}
+Aservlet
+BServlet
+
+ - 3)请求转发与请求包含比较
+- 如果在AServlet中请求转发到BServlet，那么在AServlet中就不允许再输出响应体，即不能再使用response.getWriter()和response.getOutputStream()向客户端输出，这一工作应该由BServlet来完成；如果是使用请求包含，那么没有这个限制；
+- 请求转发虽然不能输出响应体，但还是可以设置响应头的，例如：response.setContentType(”text/html;charset=utf-8”);
+- 请求包含大多是应用在JSP页面中，完成多页面的合并；
+- 请求转发大多是应用在Servlet中，转发目标大多是JSP页面；
+
+ - 4)请求转发与重定向比较
+ - 1)请求转发是一个请求，而重定向是两个请求；
+- 请求转发后浏览器地址栏不会有变化，而重定向会有变化，因为重定向是两个请求；
+ - 2)请求转发的目标只能是本应用中的资源（给出Servlet路径)，重定向的目标可以是其他应用（请求URI或者其他路径)；
+ - 3)请求转发对AServlet和BServlet的请求方法是相同的，即要么都是GET，要么都是POST，因为请求转发是一个请求；
+- 重定向的第二个请求一定是GET；
+ - 4)请求转发效率更高；当需要地址栏发生变化时，需要使用重定向；需要在下一个Servlet中获取之前Servlet设置的域，需要使用转发
+-
+
+# Filter
+- 什么是过滤器
+- 过滤器JavaWeb三大组件之一，它与Servlet很相似！不过过滤器是用来拦截请求的，而不是处理请求的。
+- 当用户请求某个Servlet时，会先执行部署在这个请求上的Filter，如果Filter“放行”，那么会继承执行用户请求的Servlet；如果Filter不“放行”，那么就不会执行用户请求的Servlet。
+- 其实可以这样理解，当用户请求某个Servlet时，Tomcat会去执行注册在这个请求上的Filter，然后是否“放行”由Filter来决定。可以理解为，Filter来决定是否调用Servlet！当执行完成Servlet的代码后，还会执行Filter后面的代码。
+
+- 过滤器之hello world
+- 其实过滤器与Servlet很相似，我们回忆一下如果写的第一个Servlet应用！写一个类，实现Servlet接口！没错，写过滤器就是写一个类，实现Filter接口。
+public class HelloFilter implements Filter {
+ public void init(FilterConfig filterConfig) throws ServletException {}
+ public void doFilter(ServletRequest request, ServletResponse response,
+ FilterChain chain) throws IOException, ServletException {
+ System.out.println("Hello Filter");
+ }
+ public void destroy() {}
+}
+
+- 第二步也与Servlet一样，在web.xml文件中部署Filter：
+
+ helloFilter
+ cn.itcast.filter.HelloFilter
+
+
+ helloFilter
+ /*(/*表示拦截所有的访问请求)
+
+
+- 当用户访问index.jsp页面时，会执行HelloFilter的doFilter()方法！在我们的示例中，index.jsp页面是不会被执行的，如果想执行index.jsp页面，那么我们需要放行！
+ public void doFilter(ServletRequest request, ServletResponse response,
+ FilterChain chain) throws IOException, ServletException {
+ System.out.println("filter start...");
+ chain.doFilter(request, response);
+ System.out.println("filter end...");
+ }
+
+
+- 有很多同学总是错误的认为，一个请求在给客户端输出之后就算是结束了，这是不对的！其实很多事情都需要在给客户端响应之后才能完成！
+
+-
+
+- 过滤器的生命周期
+- init(FilterConfig)：在服务器启动时会创建Filter实例，并且每个类型的Filter只创建一个实例，从此不再创建！在创建完Filter实例后，会马上调用init()方法完成初始化工作，这个方法只会被执行一次；
+- doFilter(ServletRequest req,ServletResponse res,FilterChain chain)：这个方法会在用户每次访问“目标资源（pattern>index.jsp)”时执行，如果需要“放行”，那么需要调用FilterChain的doFilter(ServletRequest,ServletResponse)方法，如果不调用FilterChain的doFilter()方法，那么目标资源将无法执行；
+- destroy()：服务器会在创建Filter对象之后，把Filter放到缓存中一直使用，通常不会销毁它。一般会在服务器关闭时销毁Filter对象，在销毁Filter对象之前，服务器会调用Filter对象的destory()方法。
+- 单例，同Servlet一致
+- FilterConfig
+- Filter接口中的init()方法的参数类型为FilterConfig类型。它的功能与ServletConfig相似，与web.xml文件中的配置信息对应。下面是FilterConfig的功能介绍：
+- ServletContext getServletContext()：获取ServletContext的方法；
+- String getFilterName()：获取Filter的配置名称；与元素对应；
+- String getInitParameter(String name)：获取Filter的初始化配置，与元素对应；
+- Enumeration getInitParameterNames()：获取所有初始化参数的名称。
+
+
+- FilterChain
+- doFilter()方法的参数中有一个类型为FilterChain的参数，它只有一个方法：doFilter(ServletRequest,ServletResponse)。
+- 前面我们说doFilter()方法的放行，让请求流访问目标资源！但这么说不严谨，其实调用该方法的意思是，“我（当前Filter)”放行了，但不代表其他人（其他过滤器)也放行。
+- 如果当前过滤器是最后一个过滤器，那么调用chain.doFilter()方法表示执行目标资源，而不是最后一个过滤器，那么chain.doFilter()表示执行下一个过滤器的doFilter()方法。
+- 多个过滤器执行顺序
+- 一个目标资源可以指定多个过滤器，过滤器的执行顺序是在web.xml文件中的部署顺序：
+
+ myFilter1
+ cn.itcast.filter.MyFilter1
+
+
+ myFilter1
+ /index.jsp
+
+
+ myFilter2
+ cn.itcast.filter.MyFilter2
+
+
+ myFilter2
+ /index.jsp
+
+public class MyFilter1 extends HttpFilter {
+ public void doFilter(HttpServletRequest request, HttpServletResponse response,
+ FilterChain chain) throws IOException, ServletException {
+ System.out.println("filter1 start...");
+ chain.doFilter(request, response);//放行，执行MyFilter2的doFilter()方法
+ System.out.println("filter1 end...");
+ }
+}
+public class MyFilter2 extends HttpFilter {
+ public void doFilter(HttpServletRequest request, HttpServletResponse response,
+ FilterChain chain) throws IOException, ServletException {
+ System.out.println("filter2 start...");
+ chain.doFilter(request, response);//放行，执行目标资源
+ System.out.println("filter2 end...");
+ }
+}
+
+ This is my JSP page.
+ index.jsp
+ <%System.out.println("index.jsp"); %>
+
+
+- 当有用户访问index.jsp页面时，输出结果如下：
+filter1 start...
+filter2 start...
+index.jsp
+filter2 end...
+filter1 end...
+- AFilter B Filter CFilter
+- 有点像是递归，调用filterchain的doFilter方法会放行给下一个过滤器，这个doFilter前面的代码的执行顺序是A-B-C，而后面的代码的执行顺序是C-B-A
+
+- 四种拦截方式
+- 我们来做个测试，写一个过滤器，指定过滤的资源为b.jsp，然后我们在浏览器中直接访问b.jsp，你会发现过滤器执行了！
+- 但是，当我们在a.jsp中request.getRequestDispathcer(“/b.jsp”).forward(request,response)时，就不会再执行过滤器了！也就是说，默认情况下，只能直接访问目标资源才会执行过滤器，而forward执行目标资源，不会执行过滤器！
+public class MyFilter extends HttpFilter {
+ public void doFilter(HttpServletRequest request,
+ HttpServletResponse response, FilterChain chain)
+ throws IOException, ServletException {
+ System.out.println("myfilter...");
+ chain.doFilter(request, response);
+ }
+}
+
+ myfilter
+ cn.itcast.filter.MyFilter
+
+
+ myfilter
+ /b.jsp
+
+
+ b.jsp
+
+ a.jsp
+ <%
+ request.getRequestDispatcher("/b.jsp").forward(request, response);
+ %>
+
