day23 框架之基础加强
day23 框架之基础加强
今日任务
aptana（javascript的eclipse插件）:http://www.cnblogs.com/terrylin/archive/2012/06/20/2555962.html
jquery技术，查询文档。
-
今天的总思路：读取配置文件，反射获取类信息，创建对象，监控方法的执行
SSH ： struts2 spring hibernate
SSM ：springMVC spring Mybaties
spring 核心：IOC——控制反转，创建对象，不再由着程序员，创建对象由spring管理
AOP——面向切面编程，面向整个功能（功能的实现，不止一个类）
-
反射技术
-
动态代理
-
注解技术
注解技术：老程序员看不上，新程序员特别喜欢。
使用配置文件：特别多，特别复杂（新程序员讨厌原因）
注解：简单，方便，内容少。（新程序员特别喜欢） 注解的配置：都在类上或者方法上，代码维护代价高，注解性能问题（老程序员看不上）
课堂笔记
读取配置文件的三种方式
第一种：String realPath = this.getServletContext().getRealPath("/upload");
只能在web工程中使用。
第二种：InputStream in = ClassLoader.getSystemResourceAsStream("peizhi.properties");
使用类加载器读取配置文件的方法（类加载器：加载类的对象），任何工程都可以使用
任何java工程都需要类加载器来，帮助我们加载类，运行，所以任何工程都可以使用类加载器加载配置文件。
ClassLoader是什么：加载类的对象。
第三种：ResourceBundle bundle = ResourceBundle.getBundle("peizhi");
注意：专门用来读取properties文件
演示读取配置文件的方式（第二种和第三种）：
准备接口和实现类：
配置文件准备：
思路：
-
定义接口
-
书写实现类
-
定义配置文件
模拟框架开发：接口定义好的，如何知道程序员定义的实现类？
配置文件——定义好了接口的实现类。
通过读取配置文件，可以获取到实现类的全路径，通过反射获取实现类的对象
第二种代码演示：
/**
* 测试使用类加载器，读取配置文件
* @throws Exception
*/
@Test
public void test1() throws Exception{
//获取输入流，读取配置文件
InputStream in = ClassLoader.getSystemResourceAsStream("peizhi.properties");
//InputStreamReader: 他的构造函数需要InputStream对象，将字节流转换成字符流
BufferedReader reader = new BufferedReader(new InputStreamReader(in));
String line = null;
while((line = reader.readLine()) != null){
System.out.println(line);
}
}
效果：
第三种代码演示：
/**
* 测试使用ResourceBundle，读取配置文件
* @throws Exception
*/
@Test
public void test2() throws Exception{
//创建对象，读取配置文件
//ResourceBundle 专门读取properties文件
ResourceBundle bundle = ResourceBundle.getBundle("peizhi");
String value = bundle.getString("servlet");
System.out.println(value);
}
效果：
注意：任何配置文件，修改过后，都需要重新启动java虚拟机。
原因：读取配置文件的动作只有一次。
如果想要不重新启动java虚拟机，将数据保存在数据库，然后，从数据库获取数据，再进行操作——这样的数据，一般叫做系统变量。
1、反射技术回顾
1.1、Class回顾
Class：相当于工厂在制作产品之前，先设计好的产品图纸。
反射的作用：可以动态的创建某个类的对象，然后动态调用这个类中的成员（方法和属性）。
-
对象的getClass方法
-
类名.class
-
Class类forName方法
代码演示：
/**
* 演示获取Class对象的三种方式
* @throws ClassNotFoundException
*/
@Test
public void test3() throws ClassNotFoundException {
MyServlet myServlet = new MyServlet();
System.out.println(myServlet.getClass());
System.out.println(MyServlet.class);
//clazz：这是一个源远流长的习惯
//框架经常使用第三种方式
Class clazz = Class.forName("cn.itcast.web.impl.MyServlet");
System.out.println(clazz);
}
效果：
1.2、反射类中的成员回顾
第一步：反射类中的构造方法：
通过构造方法，就可以创建类的对象
Class：
Constructor：
/**
* 演示获取对象的构造方法
* @throws Exception
*/
@Test
public void test4() throws Exception{
//读取配置文件
ResourceBundle bundle = ResourceBundle.getBundle("peizhi");
//获取类全名
String className = bundle.getString("servlet");
//获取类的构造方法
Class<?> clazz = Class.forName(className);
/*Constructor[] constructors = clazz.getConstructors();
for (Constructor constructor : constructors) {
System.out.println(constructor);
}*/
//获取指定的构造方法
//parameterTypes：给的是构造函数的参数
Constructor<?> constructor = clazz.getConstructor(null);
System.out.println(constructor);
Constructor<?> constructor2 = clazz.getConstructor(String.class,String.class);
System.out.println(constructor2);
//根据构造函数创建对象
//initargs:构造函数使用需要的参数
Object newInstance = constructor.newInstance(null);
System.out.println(newInstance);
Object newInstance2 = constructor2.newInstance("req","res");
System.out.println(newInstance2);
}
效果：
反射类中的成员变量：
Class：
/**
* 演示获取成员变量（属性）
*
* @throws Exception
*/
@Test
public void test5() throws Exception {
// 读取配置文件
ResourceBundle bundle = ResourceBundle.getBundle("peizhi");
// 获取类全名
String className = bundle.getString("servlet");
// 获取Class对象
Class<?> clazz = Class.forName(className);
Field[] declaredFields = clazz.getDeclaredFields();
/*for (Field field : declaredFields) {
System.out.println(field);
}*/
Field declaredField = clazz.getDeclaredField("request");
System.out.println(declaredField);
}
效果：
反射类中的成员方法：
获取所有方法：
/**
* 演示获取类中的成员方法
*
* @throws Exception
*/
@Test
public void test6() throws Exception {
// 读取配置文件
ResourceBundle bundle = ResourceBundle.getBundle("peizhi");
// 获取类全名
String className = bundle.getString("servlet");
// 获取Class对象
Class<?> clazz = Class.forName(className);
Method[] methods = clazz.getMethods();
for (Method method : methods) {
System.out.println(method);
}
System.out.println("================");
Method method = clazz.getMethod("doGet", java.lang.String.class,java.lang.String.class);
System.out.println(method);
System.out.println("==============");
//演示调用方法obj:调用方法的对象，args：方法的参数
Object invoke = method.invoke(clazz.newInstance(), "haha","hehe");
System.out.println(invoke);
}
效果：
案例：模拟BeanUtils封装数据演示：
思路：
-
需要一个封装数据的对象（Person）
-
需要一个封装数据的map集合（key值和Person的字段名称一致）
-
获取Person的Class对象，只有获取Class对象，才能获取到所有的字段（属性）
-
获取所有字段
-
循环所有字段和map集合，当key值和字段名称一致，就封装数据
要使用的API：
Class：
Field：
代码演示:
测试类：
/**
* 演示模拟beanUtils封装数据
*
* @throws Exception
*/
@Test
public void test7() throws Exception {
//第一步：创建要被封装数据的对象
User u = new User();
System.out.println(u);
//String:用来保存属性的名称（对应User中的属性）
//Object:要被封装的数据，任意类型
Map<String, Object> map = new HashMap<String, Object>();
map.put("name", "张三");
map.put("age", 11);
//封装数据，使用BeanUtils.populate(u, map);
BeanUtils.populate(u, map);
System.out.println(u);
}
工具类：
package cn.itcast.utils;
import java.lang.reflect.Field;
import java.util.Map;
public class BeanUtils {
public static void populate(Object obj, Map<String, Object> map) {
//第一步：通过Class对象来获取obj对象中的成员变量
Class<?> clazz = obj.getClass();
Field[] declaredFields = clazz.getDeclaredFields();
//第二步：遍历循环所有的字段，将数据封装进去
for (Field field : declaredFields) {
for (String key : map.keySet()) {
//判断，当前的字段名称是否和map集合中key值，一致，一致，才能封装数据
if(key.equals(field.getName())){
//封装数据
//取消访问的检查
field.setAccessible(true);
try {
field.set(obj, map.get(key));
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
}
效果：
2、动态代理
2.1、动态代理介绍
struts2 、 hibernate 底层使用的动态代理。
Spring 在AOP当中，使用了大量的动态代理，JDK自带的接口代理（有接口才能代理），子类代理（cglib代理）
动态代理：访问被代理的类，进行拦截，处理，处理完了，放行
代理设计模式：
注意：以上还只是代理设计模式，怎么变成动态代理？上面的故事，如果改成，看到姐姐之后，直接上帝创建了妹妹，就是动态代理。
2.2、动态代理演示
1、先获取创建代理对象的类，调用它的方法，创建出一个代理对象
2、代理对象具体要做什么事情（代理策略），需要设置
创建代理类的对象：
创建代理对象的方法：
代理策略对象：
代理策略方法：
需求和步骤（模拟框架读取配置文件，创建代理对象，并调用接口方法）：
-
读取配置文件
-
获取类全名
-
反射获取Class对象
-
获取当前类接口（根据接口做代理）
-
创建代理类（Proxy）
-
代理策略：监控方法执行
-
获取代理类的接口方法，调用执行
代码演示：
/**
* 演示动态代理
*/
@Test
public void test8()throws Exception{
//1） 读取配置文件
ResourceBundle bundle = ResourceBundle.getBundle("peizhi");
//2） 获取类全名
String className = bundle.getString("servlet");
//3） 反射获取Class对象
final Class<?> clazz = Class.forName(className);
//4） 获取当前类接口（根据接口做代理）
Class<?>[] interfaces = clazz.getInterfaces();
//以上都是反射操作
//5） 创建代理类（Proxy），设置了代理的策略
Object obj = Proxy.newProxyInstance(clazz.getClassLoader(), interfaces, new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
//6） 代理策略：监控方法执行
//method 当前被调用的方法
//args 是调用方法时候的参数
System.out.println("======方法启动=====");
System.out.println("method:"+method);
for (Object dd : args) {
System.out.println(dd);
}
//method是一个方法对象，可以调用它的invoke方法，让他去执行
if(method.getName().equals("doGet")){
Object invoke = method.invoke(clazz.newInstance(), args);
}
System.out.println("======执行完成=====");
return null;
}
});
//7） 获取代理类的接口方法，调用执行
//通过接口数组的第一个接口，获取第一个接口中的所有方法
Method[] methods = interfaces[0].getMethods();
//通过操作methods方法数组，获取第一个方法对象，通过他的invoke方法，调用方法执行
methods[0].invoke(obj, "req","res");
}
//为什么要用动态代理？
//1）可以通过代理对象，对指定的类的方法进行修改（拦截或者增强），使用动态代理修改类，不需要修改原来的代码，因为我们是创建一个新的类
//2)一次动态代理，可以对当前指定的类，的所有方法，进行拦截或者增强的操作
/**
* 继承
* 当你要写的这个类，与原来要被增强的那个类是同一类型事物（animal cat dog）
*
* 装饰设计模式
* 当你要写的这个类，与原来要被增强的那个类不是同一类型事物（animal dianziGou / 对request对象进行增强，也是使用装饰设计模式）
*
* 动态代理
* 需要，在java虚拟机启动之后，再去修改指定的类，那么就使用动态代理
*
* 怎么就突然出现了一个类呢？
* Person.java -->javac命令 Person.class
* 创建代理类，底层机制类似javac命令，所以不属于java范畴，后期，入职sun公司，请回来告诉我。
*
* */
总结：
使用动态代理中，可以一个类的方法执行前后做增强和过滤的动作
2.3、动态代理完成全站乱码处理
过滤器：全站乱码过滤器
需求：使用动态代理方式，处理乱码
-
过滤器：对请求进行增强
-
过滤器：过滤任务写在doFilter方法
-
过滤任务：通过创建代理对象来增强原来的request
-
根据不同请求方式处理：
-
Post：setCharacterEncoding（"utf-8"）'
-
Get：根据不同的方法，不同处理
-
getParameter方法：new String();
-
getParameterValues方法：遍历循环，new String();
-
getParameterMap：循环遍历，new String();
-
request对象还要其他方法，其他方法执行不做任何处理
package cn.itcast.filter;
import java.io.IOException;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Map;
import java.util.Set;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class EncodingFilter2 implements Filter {
@Override
public void init(FilterConfig filterConfig) throws ServletException {
}
@Override
public void doFilter(ServletRequest request, ServletResponse response,
FilterChain chain) throws IOException, ServletException {
final HttpServletRequest req = (HttpServletRequest) request;
HttpServletResponse res = (HttpServletResponse) response;
res.setContentType("text/html;charset=utf-8");
// 使用动态代理创建代理对象，对request进行增强
HttpServletRequest myrequest = (HttpServletRequest) Proxy
.newProxyInstance(req.getClass().getClassLoader(), req
.getClass().getInterfaces(), new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method,
Object[] args) throws Throwable {
// 设置代理策略，对request的获取数据的方法进行增强
//获取请求方式
String method2 = req.getMethod();
if(method2.equalsIgnoreCase("post")){
req.setCharacterEncoding("utf-8");
return method.invoke(req, args);
}else if(method2.equalsIgnoreCase("get")){
//获取请求参数的方法
//根据不同的方法，进行不同增强操作
if("getParameter".equals(method.getName())){
String parameter = req.getParameter((String)args[0]);
if(parameter != null){
parameter = new String(parameter.getBytes("iso-8859-1"),"utf-8");
}
return parameter;
}else if("getParameterValues".equals(method.getName())){
String[] values = req.getParameterValues((String)args[0]);
if(values != null){
for (int i = 0; i < values.length; i++) {
values[i] = new String(values[i].getBytes("iso-8859-1"),"utf-8");
}
}
return values;
}else if("getParameterMap".equals(method.getName())){
Map<String, String[]> map = req.getParameterMap();
if(map != null){
Set<String> keySet = map.keySet();
for (String key : keySet) {
String[] values = map.get(key);
for (int i = 0; i < values.length; i++) {
values[i] = new String(values[i].getBytes("iso-8859-1"),"utf-8");
}
}
}
return map;
}else{
return method.invoke(req, args);
}
}else{
return method.invoke(req, args);
}
}
});
chain.doFilter(myrequest, res);
}
@Override
public void destroy() {
}
}
3、注解技术
3.1、注解和注释区别
注释：它是对程序中的代码进行解释说明。注释是给人看。
注解：它是给程序使用的。在程序运行的时候（编译的时候），会根据相应的注解，然后完成对应的操作。注解经常需要和反射一起使用。
早期的程序：
基本是程序配合配置文件一起工作，在程序运行的时候，会读取配置文件中的数据。
现在程序：
在程序运行的时候，不再使用配置文件（少量使用配置文件），而是在程序加入注解来代替配置文件。
3.2、注解格式和JDK注解简单演示
注解的格式：@注解的名称( key=value , key=value, key=value。。。。。。 )
JDK中自带的3个注解：
1、方法复写的时候注解：
使用Override注解声明当前方法是复写父类的方法，或者是实现了接口中的方法
jdk1.5@override不支持接口的方法复写，1.6以上可以
2、过时的方法注解：
@Deprecated它声明某个方法已经过时。
3、消除程序中的警告
@SuppressWarnings 消除警告。
3.3、自己定义注解的实现
自己定义注解：
格式：public @interface 注解名字{
定义注解的成员变量;
}
第一步：
效果：
自定义注解：
自定义注解使用：
3.4、注解的细节
@Test注解不能出现在类上：
获取Junit源代码：
第一步：找到junit在eclipse中的位置
第二步：使用反编译神器，将class文件还原成.java文件
发现：在@Test注解的底层类上有两个注解
@Retention(RetentionPolicy.RUNTIME)
指定注解什么时候存在
@Target({java.lang.annotation.ElementType.METHOD})
指定注解可以写在什么位置
1、在定义注解的时候，可以指定注解什么时候存在——@Retention
这个注解是存在于源代码上，还是编译之后的class文件上，还是运行时期也要存在。
@Retention 使用jdk中的Retention 来声明自己的注解将来在程序中存活的具体时间
RetentionPolicy：声明注解存活的时间：
代码演示：
注意：声明注解的存活时间时，使用runtime是给反射程序使用的。
2、在定义注解的时候，指定注解可以写在什么位置——@Target
注解是使用在类上，方法上，构造方法上，成员变量，或者是其他注解上。
在Java中提供的@Target注解，声明自己 定义的注解在其他的类中的存在位置。
代码演示：
效果:
演示代码（反射获取注解）：
@Test
@MyAnnotation
public void test9() throws Exception{
Method method = this.getClass().getMethod("test9", null);
MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
System.out.println(annotation);
}
效果：
-
在注解中定义成员变量
格式：数据类型 变量名() default 默认值
测试代码：
效果：
3.5、使用注解完成数据库连接的获取
定义注解：
package cn.itcast.zhujie;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import java.lang.annotation.RetentionPolicy;
@Retention(RetentionPolicy.RUNTIME)
@Target({java.lang.annotation.ElementType.METHOD})
public @interface MyAnnotation {
String driverClass();
String jdbcUrl();
String user();
String password();
}
使用注解：
package cn.itcast.test;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.DriverManager;
import org.junit.Test;
import cn.itcast.zhujie.MyAnnotation;
public class TestUtils2 {
@MyAnnotation(driverClass="com.mysql.jdbc.Driver",jdbcUrl="jdbc:mysql:///day14",user="root",password="root")
@Test
public void test() throws Exception{
//获取注解上的值，获取数据库连接
Method method = this.getClass().getMethod("test", null);
MyAnnotation annotation = method.getAnnotation(MyAnnotation.class);
String driverClass = annotation.driverClass();
String jdbcUrl = annotation.jdbcUrl();
String user = annotation.user();
String password = annotation.password();
Class.forName(driverClass);
Connection connection = DriverManager.getConnection(jdbcUrl, user, password);
System.out.println(connection);
}
}
