Web基础加强

最新推荐文章于 2022-05-17 10:14:48 发布

yeiweilan

最新推荐文章于 2022-05-17 10:14:48 发布

阅读量302

点赞数

分类专栏： web开发前后端文章标签： web

本文链接：https://blog.csdn.net/yeiweilan/article/details/72473161

版权

web开发前后端专栏收录该内容

14 篇文章 5 订阅

订阅专栏

注解

什么是注解
语法：@注解名称
注解的作用：替代xml配置文件！
servlet3.0中，就可以不再使用web.xml文件，而是所有配置都使用注解！
注解是由框架来读取使用的！
.注解的使用
定义注解类：框架的工作
使用注解：我们的工作
读取注解（反射）：框架的工作
定义注解类
@interface A{} //天下所有的注解都是Annotation的子类！
注解的作用目标：
类
方法
构造器
参数
局部变量
包

注解的属性

定义属性：

    @interface 
    MyAnno1 {
	int age();
	String name();
    }

使用注解时给属性赋值

   @MyAnno1(age=100, name="zhangSan")

注解属性的默认值：在定义注解时，可以给注解指定默认值！

 int age() default 100;
 在使用注解时，可以不给带有默认值的属性赋值！

名为value的属性的特权
当使用注解时，如果只给名为value的属性赋值时，可以略“value=”，例如： @MyAnno1(value=“hello”)，可以书写成 @MyAnno1(“hello”)
注解属性的类型
8种基本类型
String
Enum
Class

实例：
@MyAnno1(
	a=100,
	b="hello",
	c=MyEnum1.A,
	d=String.class,
	e=@MyAnno2(aa=200, bb="world"),
	f=100
)
public class Demo3 {

}

@interface MyAnno1 {
	int a();
	String b();
	MyEnum1 c();
	Class d();
	MyAnno2 e();
	int[] f();
}
public enum Myenuml{
A,B,C}

注解的作用目标限定以及保存策略限定

让一个注解，它的作用目标只能在类上，不能在方法上，这就叫作用目标的限定！
在定义注解时，给注解添加注解，这个注解是@Target。该注解有一个属性value，类型为ElementType[]，它是枚举类型

public @interface Target {
ElementType[] value();
}
public enum ElementType {
TYPE,FIELD,METHOD,PARAMETED,CONSTRUCTOR,LOCAL_VARIABLE,ANNOCATION_TYPE,PACKAGE
}

实例：
@Target(value={ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
@interface MyAnno1 {
	
}

保留策略
源代码文件（SOURCE）：注解只在源代码中存在，当编译时就被忽略了
字节码文件（CLASS）：注解在源代码中存在，然后编译时会把注解信息放到了class文件，但JVM在加载类时，会忽略注解！
JVM中（RUNTIME）：注解在源代码、字节码文件中存在，并且在JVM加载类时，会把注解加载到JVM内存中（它是唯一可反射注解！）

实例：限定注解的保留策略
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnno1 {
}

反射注解

反射泛型信息

abstract class A<T> {
	public A() {
//		Class clazz = this.getClass();//得到子类的类型
//		Type type = clazz.getGenericSuperclass();//获取传递给父类参数化类型
//		ParameterizedType pType = (ParameterizedType) type;//它就是A<String>
//		Type[] types = pType.getActualTypeArguments();//它就是一个Class数组
//		Class c = (Class)types[0];//它就是String
//		
		Class c = (Class)((ParameterizedType)this.getClass()
				.getGenericSuperclass()).getActualTypeArguments()[0];
		
		System.out.println(c.getName());
	}
}

class B extends A<String> {
	
}

class C extends A<Integer> {
	
}

反射注解需要从作用目标上返回
类上的注解，需要使用Class来获取
方法上的注解，需要Method来获取
构造器上的注解，需要Construcator来获取
成员上的，需要使用Field来获取Class， Method、Constructor、Field：AccessibleObject
它们都有一个方法：
Annotation getAnnotation(Class)，返回目标上指定类型的注解！
Annotation[] getAnnotations()，返回目标上所有注解！

Servlet3.0特性

新特性概括
使用@WebServlet、@WebFilter、@WebListener三个注解来替代web.xml文件中的Servlet、Filter、Listener的配置；
Servlet异步处理：当Servlet处理比较费时的问题时，这会让客户感觉到很卡。当使用异常处理时可以把已经处理好的内容先一步响应给客户端浏览器，然后使用另一个线程来完成费时的操作，也就是把内容一部分一部分的显示出来；
上传组件：不用再使用fileupload等第三方的上传组件，使用Servlet3.0的上传组件会更方便。

注解替代配置文件

代码演示：

 @WebServlet(
urlPatterns={"/AServlet"}, 
initParams={@WebInitParam(name="paramName",value="paramValue")},
		loadOnStartup=1
)
public class AServlet extends HttpServlet {
	public void init(ServletConfig config) throws ServletException {
		System.out.println(config.getInitParameter("paramName"));
	}
	public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
		request.setCharacterEncoding("utf-8");
		response.setContentType("text/html;charset=utf-8");
		response.getWriter().print("Hello World!");
	}
}

@WebFilter(urlPatterns={"/*"}, 
dispatcherTypes={DispatcherType.REQUEST, DispatcherType.FORWARD})
public class AFilter implements Filter {
	public void destroy() {}

	public void doFilter(ServletRequest request, ServletResponse response,
			FilterChain chain) throws IOException, ServletException {
		System.out.println("start filter");
		chain.doFilter(request, response);
		System.out.println("end filter");
	}

	public void init(FilterConfig fConfig) throws ServletException {}
}

@WebListener()
public class AListener implements ServletContextListener {
	public void contextDestroyed(ServletContextEvent arg0) {
		System.out.println("服务器关闭");
	}

	public void contextInitialized(ServletContextEvent arg0) {
		System.out.println("服务器启动");
	}
}

servlet异步处理

得到AsyncContext:异步上下文对象
AsyncContext ac = request.startAsync(request,response);
给上下文一个Runnable对象，启动它
ac.start(new Runnable() {
public void run() {
…
} });
让浏览器支持异步
@WebServlet(urlPatterns="/AServlet", asyncSupported=true)
这个必须设置，否则有时异步会失败
resp.setContentType(“text/html;charset=utf-8”);
IE如果不能正常输出，这说明响应体大小不足512B，那你需要多输出点废话！
AsyncContext#complete()：通知Tomcat我们异步线程已经执行结束了！这让Tomcat才会及时的断开与浏览器的连接！
内部类中要是用外部类的局部变量，必须在外部类的变量前加 final

代码演示：
 public class Aservlet extends HttpServlet {

public  void doGet( final HttpServletRequest request,
		final  HttpServletResponse response)
		throws ServletException, IOException {
	    response.setContentType("text/html;charset=utf-8");
	    /*for(int i=0;i<=512;i++){
	    	response.getWriter().print("A");}
	   response.getWriter().flush();*/
	    final AsyncContext ac=request.startAsync(request, response);
	           ac.start(new Thread(){
	    	public void run(){
	    	println(response,"现在开始:</br>");
	             sleepp(2000);
				for(char c='A';c<='Z';c++){
	    		println(response, c+" ");
	    		   sleepp(250);}
				ac.complete();
	    	}
	    
	    });
	   
	    }
public void println(HttpServletResponse response,String text){
	try {
		response.getWriter().print(text);
		response.getWriter().flush();
	} catch (IOException e) {
		
	}
}
public void sleepp(long ms){
	 try {
			Thread.sleep(ms);
		} catch (Exception e) {
		}
}
}

上传支持

上传的步骤：
使用request.getPart(“字段名”)，得到Part实例，
　　 Part：
　　　 String getContentType()：获取上传文件的MIME类型
　　　 String getName()：获取表单项的名称，不是文件名称
　　　 String getHeader(String header)：获取指定头的值
　　　 long getSize()：获取上传文件的大小
　　　 InputStream getInputStream()：获取上传文件的内容
　　 void write(String fileName)：把上传文件保存到指定路径下
默认Servlet是不支持使用上传组件：需要给Servlet添加一个注解: @MultipartConfig
它没有提供获取上传文件名称的方法：

<form action="/a1/UploadServlet" method=“post” enctype=“multipart/form-data”>
用户名：<input type=“text” name=“username”/>

照　片：<input type=“file” name=“file1” />

<input type=“submit” value=“提交”/>

@UploadServlet(urlPatterns={"/UploadServlet"})
@MultipartConfig(maxFileSize=1024 * 1024)

public class UploadServlet extends HttpServlet {
public void doPost(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
request.setCharacterEncoding("utf-8");
response.setContentType("text/html;charset=utf-8");

String username = request.getParameter("username");[还是用原来方法来获取普通表单项的内容]
response.getWriter().print("size: " + username + "<br/>");

Part part = request.getPart("file1")[获取文件表单项的内容，返回值为Part];sponse.getWriter().print("size: " + part.getSize[打印文件的大小]() + "<br/>");
		response.getWriter().print("type: " + part.getContentType[打印文件的类型]() + "<br/>");
		response.getWriter().print("name: " + part.getName[打印文件表单项的filedName，而不是fileName。]() + "<br/>");

		String name = part.getHeader("content-disposition")[获取当前文件表单项的指定头信息];  
		String fileNameTmp = name.substring(name.indexOf("filename=")+10);  
		String fileName = fileNameTmp.substring(0,fileNameTmp.indexOf("\""));
[获取上传文件的名称！因为Part没有提供获取fileName的方法，所以需要自己来写方法处理这一问题]		
		System.out.println("fileName: " + fileName);

		String savepath = this.getServletContext().getRealPath("/uploads");
		part.write(savepath + "/" + fileName);[把文件保存到指定路径]
	}
	}

动态代理

AOP（面向切面编程)
在运行时，动态创建一组指定的接口的实现类对象！（在运行时，创建实现了指定的一组接口的对象）

代理用途（必须看懂）

代码：

接口：
public interface Waiter {
	public void serve();
}

实现类：
public class MyWaiter implements Waiter {
	public void serve() {
		System.out.println("服务...");
	}
}

主题：
public class MainApp1 {
	public static void main(String[] args) {
		ClassLoader loader = MainApp1.class.getClassLoader();
		Class[] cs = {Waiter.class};
		Waiter target = new MyWaiter();
		MyInvocationHandler h = new MyInvocationHandler(target);
		Waiter waiter = (Waiter)Proxy.newProxyInstance(loader, cs, h);
		waiter.serve();
	}
}

class MyInvocationHandler implements InvocationHandler {
	public Waiter target;
	public MyInvocationHandler(Waiter 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;
	}
}

类加载器

Java提供了三种类加载器，分别是：
bootstrap classloader：引导类加载器，加载rt.jar中的类；
sun.misc.Launcher $E x t C l a s s L o a d e r ：扩展类加载器，加载 l i b / e x t 目录下的类； s u n . m i s c . L a u n c h e r$ AppClassLoader：系统类加载器，加载CLASSPATH下的类，即我们写的类，以及第三方提供的类。
通常情况下，Java中所有类都是通过这三个类加载器加载的。

自定义类加载器

ClassLoader加载类都是通过loadClass()方法来完成的，loadClass()方法的工作流程如下：
调用findLoadedClass在JVM的方法区中查看已加载过的类！即判断当前类是否已经被加载过！()方法查看该类是否已经被加载过了，如果该没有加载过，那么这个方法返回null；
判断findLoadedClass()方法返回的是否为null，如果不是null那么直接返回，这可以避免同一个类被加载两次；
如果findLoadedClass()返回的是null，那么就启动代理模式（委托机制），即调用上级的loadClass()方法，获取上级的方法是getParent()，当然上级可能还有上级，这个动作就一直向上走；
如果getParent().loadClass()返回的不是null，这说明上级加载成功了，那么就加载结果；
如果上级返回的是null，这说明需要自己出手了，这时loadClass()方法会调用本类的findClass()方法来加载类；
这说明我们只需要重写ClassLoader的findClass()方法，这就可以了！如果重写了loadClass()方法覆盖了代理模式！
我们知道要自定义一个类加载器，只需要继承ClassLoader类，然后重写它的findClass()方法即可。那么在findClass()方法中我们要完成:
找到class文件，把它加载到一个byte[]中；
调用defineClass()方法，把byte[]传递给这个方法即可。
FileSystemClassLoader
public class FileSystemClassLoader extends ClassLoader {
private String classpath[这是它的地盘！因为类加载器都是片警，它需要有自己的地盘！];

	public FileSystemClassLoader() {}
	
	public FileSystemClassLoader[创建类加载器时，就要为其指定负责的地盘！它只会到这里去查找类！](String classpath) {
		this.classpath = classpath;
	}
	
	@Override
	public Class<?> findClass(String name) throws ClassNotFoundException {
		try {
			byte[] datas = getClassData(name);[通过类名称找到.class文件，把文件加载到一个字节数组中。]
			if(datas [如果返回的字节数组为null，说明没有找到这个类，抛出异常]== null) {
				throw new ClassNotFoundException("类没有找到：" + name);
			}
			return this.defineClass[它可以把字节数组变成Class对象！defineClass()是ClassLoader的方法，它的作用是把字节数组变成Class对象！](name, datas, 0, datas.length);
		} catch (IOException e) {
			e.printStackTrace();
			throw new ClassNotFoundException("类找不到：" + name);
		}
	}

	private byte[] getClassData(String name) throws IOException {
		name = name.replace(".", "\\") + ".class";
		File classFile = new File(classpath, name);
		return FileUtils[commons-io.jar中的类].readFileToByteArray(classFile);
	}
}
		ClassLoader loader = new FileSystemClassLoader("F:\\classpath");
		Class clazz = loader.loadClass("cn.itcast.utils.CommonUtils");
		Method method = clazz.getMethod("md5", String.class);
		String result = (String) method.invoke(null, "qdmmy6");
		System.out.println(result);

yeiweilan

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Web基础加强

泛型泛型类具有一个或多个类型变量的类，称为泛型类实例： class fun&amp;lt;T&amp;gt; { } 在创建泛型类实例时，需要为其类型变量赋值 fun&amp;lt;String&amp;gt; a = new fun&amp;lt;String&amp;gt;(); 如果创建实例时，不给类型变量赋值，那么会有一个警告！
复制链接

扫一扫