反射

/**
 *java.lang.Class类:继承了Object类,描述了类的相关信息，是java反射机制的入口。
 *一个类中信息常见的组成:
 *构造函数:无,不能通过new关键创建Class对象,一般通过Class.forName(全类名)获取Class对象;
 *常用方法:
 *    getDeclaredFields():返回 Field 对象的一个数组，这些对象反映此 Class 对象所表示的类或接口所声明的所有字段。
 *    getDeclaredMethods() 
          返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。
    getDeclaredConstructors() 
          返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法
      getModifiers():返回类的修饰符。0代表默认，1代表public
      getSimpleName():返回简单类名,不包含包名。
      getName():返回全类名,包含包名。
      getSuperclass():返回父类类型
      getInterfaces():返回实现的接口类型
      
 *1.成员变量或属性:Field
 *    getModifiers():返回属性的修饰符。0代表默认，1代表public,2代表private,4代表protected
 *    getType():返回属性的类型
 *    getName():返回属性名称
 *2.成员方法:Method
 *    getModifiers():返回方法的修饰符
 *    getReturnType():返回方法的返回值类型
 *    getName():返回方法名
 *  getParameterTypes():返回方法的参数类型
 *  getExceptionTypes():返回方法声明的异常类型
 *3.构造方法:Constructor
 *  getModifiers():返回构造方法的修饰符        
 *  getName():返回构造方法名
 *  getParameterTypes():返回构造方法的参数类型
 *  
 */
public class TestClass {
    
    /**
     * 获取类的相关信息
     */
    public void testClassinfo(){
        try {
            Class clazz = Class.forName("cn.zzsxt.entity.Student");
            Package pack =clazz.getPackage();
            System.out.println(pack.getName());
//            String clazzName = clazz.getName(); //包名+类名
            int modify = clazz.getModifiers();//获取类的修饰符
            String simpleName = clazz.getSimpleName();//类名
            Class superClazz = clazz.getSuperclass();//获取父类
            Class[] interfaceClazz = clazz.getInterfaces();//获取实现的接口
            System.out.println("修饰符:"+modify);
            System.out.println("类名:"+simpleName);
            System.out.println("继承的父类:"+superClazz);
            System.out.println("实现的接口:"+Arrays.toString(interfaceClazz));
            
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        
    }
    /**
     * 获取属性信息
     */
    public void testField(){
        try {
            //获取Student对象对应的Class信息
            Class clazz = Class.forName("cn.zzsxt.entity.Student");//动态加载一个类参数应该为该类的全类名(包名+类名)
            Field[] fs = clazz.getDeclaredFields();//获取该类中的属性信息
            for (Field field : fs) {
                int modifer = field.getModifiers();//获取修饰符 1:public,2:private,4:protected 0:默认
                Class fieldClass = field.getType();//获取属性的类型
                String fieldName = field.getName();//获取属性名称
                System.out.println(modifer+"---"+fieldClass+"---"+fieldName);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    /**
     * 获取方法信息
     */
    public void testMethod(){
        try {
            Class clazz = Class.forName("cn.zzsxt.entity.Student");//动态加载一个类参数应该为该类的全类名(包名+类名)
            Method[] ms = clazz.getDeclaredMethods();//获取类中的方法信息
            for (Method method : ms) {
                int modify = method.getModifiers();//获取方法的修饰符
                Class returnTypeClass = method.getReturnType();//获取方法的返回值类型
                String methodName = method.getName();//获取方法名
                Class[] paramClazz = method.getParameterTypes();//获取参数类型
                Class[] exceptionClazz = method.getExceptionTypes();//获取异常类型
                System.out.println(modify+"---"+returnTypeClass+"---"+methodName+"---"+Arrays.toString(paramClazz)+"---"+Arrays.toString(exceptionClazz));
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    
    /**
     * 获取构造函数
     */
    public void testConstructor(){
        try {
            Class clazz = Class.forName("cn.zzsxt.entity.Student");
            Constructor[] cs=  clazz.getConstructors();
            for (Constructor constructor : cs) {
                int modify = constructor.getModifiers();//获取构造函数的修饰符
                String constructorName = constructor.getName();//获取构造函数的名称
                Class[] paramClazz = constructor.getParameterTypes();//获取构造函数的参数
                System.out.println(modify+"---"+constructorName+"---"+Arrays.toString(paramClazz));
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    
    public static void main(String[] args) {
        TestClass test = new TestClass();
        test.testClassinfo();
//        test.testField();
//        test.testMethod();
//        test.testConstructor();
    }
}

/**
 *java.lang.Class类
 *常用方法:
 * 获取Class类型对象的方式:
 * 1.Class.forName(全类名);***
 * 2.类名.class   eg:TestClass2.class
 * 3.在成员方法中使用 this.getClass()方法
 * 
 * 使用Class类型创建对象===>调用 newInstance()方法可以动态创建对象
 * Class clazz = Class.forName("cn.zzsxt.entity.Student");
 * Object obj=  clazz.newInstance();
 *  
 *    Field[] getDeclaredFields():获取类中所有的属性 ***
 *    Field getDeclaredField(String name):获取类中指定名称的属性信息
 *    Method[] getDeclaredMethods():获取类中所有的方法 ***
 *    Method getDeclaredMethod(String name,Class...clazzType):获取类中指定名称的方法信息
 *    getDeclaredConstructors() **
          返回 Constructor 对象的一个数组，这些对象反映此 Class 对象表示的类声明的所有构造方法
      getModifiers():返回类的修饰符。0代表默认，1代表public
      getSimpleName():返回简单类名,不包含包名。
      getName():返回全类名,包含包名。
      getSuperclass():返回父类类型
      getInterfaces():返回实现的接口类型 
 * 
 */
public class TestClass2 {
    public void m(){
//        Class clazz = this.getClass();
//        Class clazz = Class.forName("cn.zzsxt.demo.TestClass2");
//        Class clazz = TestClass2.class;
    }
    public static void main(String[] args) throws Exception{
//        Student student = new Student();//创建对象
        
//        Class clazz = Class.forName("cn.zzsxt.entity.Student");
        Class clazz = Student.class;
        Object obj = clazz.newInstance();
        System.out.println(obj);
        //获取属性信息
//        clazz.getDeclaredFields()//获取所有属性的信息
        Field field = clazz.getDeclaredField("name");//获取指定名称的属性信息
        int modify = field.getModifiers();
        Class fieldType = field.getType();
        String fieldName = field.getName();
        System.out.println(modify+"---"+fieldType+"---"+fieldName);
//        clazz.getDeclaredMethods();//获取所有方法
        Method method = clazz.getDeclaredMethod("setName", String.class);
        int modifyMethod = method.getModifiers();
        Class returnType = method.getReturnType(); 
         String methodName = method.getName();
        System.out.println(modifyMethod+"---"+returnType+"----"+methodName);
        Package pack = clazz.getPackage();
        System.out.println("包名:"+pack.getName());
    }
}

/**
 * java.lang.reflect.Constructor类:提供关于类的单个构造方法的信息以及对它的访问权限。 
 * getModifies():获取构造函数的修饰符
 * getName():获取构造函数的名称
 * getParameterTypes():获取构造函数的参数类型 
 *调用无参构造和有参构造的方式:
 *无参构造:Class.forName(...).newInstance()
 *有参构造:
 *1.获取有参构造方法的Constructor对象
 *    Class clazz = Class.forName("cn.zzsxt.entity.Student");
    Constructor constructor = clazz.getDeclaredConstructor(String.class,int.class,double.class
  2.调用newInsatnce(Object...objs)方法创建对象
    Object obj = constructor.newInstance("zhangsan",23,80);
 */
public class TestConstructor {
    public static void main(String[] args) throws Exception{
//        Student student = new Student();
//        Class.forName("cn.zzsxt.entity.Student").newInstance();//相当于调用无参构造函数创建对象
//        Student student = new Student("zhangsan",23,80);
        Class clazz = Class.forName("cn.zzsxt.entity.Student");
        Constructor constructor = clazz.getDeclaredConstructor(String.class,int.class,double.class);
        Object obj = constructor.newInstance("zhangsan",23,80);
        System.out.println(obj);
    }
    
}

/**
 * java.lang.reflect.Field类:Field提供有关类或接口的单个字段的信息，以及对它的动态访问权限。
 *  getName():获取属性名称
 *  getType():获取属性类型
 *  getModifies():获取修饰符
 *  set(Object obj, Object value) 将指定对象变量上此 Field 对象表示的字段设置为指定的新值。
 *  get(Object obj) 返回指定对象上此 Field 表示的字段的值。
 */
public class TestField {
    public static void main(String[] args) throws Exception{
//        Student student = new Student();
//        student.setName("zhangsan");
//        student.getName();
        Class clazz = Class.forName("cn.zzsxt.entity.Student");
        Object obj = clazz.newInstance();  
        Field field = clazz.getDeclaredField("name");
        field.setAccessible(true);//设置访问控制，true为可以访问private修饰的属性
        field.set(obj, "zhangsan");//赋值
        System.out.println(field.get(obj));//取值
    }
    
}

/**
 * java.lang.reflect.Method类:Method 提供关于类或接口上单独某个方法（以及如何访问该方法）的信息
 * getModifiers() :获取修饰符
 * getReturnType():获取返回值类型
 * getName():获取方法名
 * getParameterTypes():获取方法的参数列表类型
 * getExceptionTypes():获取异常类型
 * 
 * invoke(Object obj, Object... args) ***:对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。  
 * 
 */
public class TestMethod {
    public static void main(String[] args) throws Exception{
//        Student student = new Student();
//        student.setName("zhangsan");
//        student.getName();
        Class clazz = Class.forName("cn.zzsxt.entity.Student");
        Object obj = clazz.newInstance();
        Method setterMethod = clazz.getMethod("setName", String.class);
        //回调方法student.setName("zhangsan")
        setterMethod.invoke(obj, "zhangsan");//第一个参数为对象,第二个参数为方法的参数值
        Method getterMethod =clazz.getMethod("getName", null);
        //回调方法:student.getName();
        Object result = getterMethod.invoke(obj, null);
        System.out.println(result);
    }
    
}

public class Student implements Serializable {
    private String name;
    private int age;
    private double score;
    
    public Student() {
        
    }
    
    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public double getScore() {
        return score;
    }
    public void setScore(double score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
    }
    
}

public class User implements Serializable{
    private int userId;
    private String userName;
    private String userPass;
    
    public User(){
        
    }
    public User(int userId,String userName,String userPass){
        this.userId=userId;
        this.userName=userName;
        this.userPass=userPass;
    }
    
    public int getUserId() {
        return userId;
    }
    public void setUserId(int userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserPass() {
        return userPass;
    }
    public void setUserPass(String userPass) {
        this.userPass = userPass;
    }
    
}

public class MyHibernate {
    /**
     * User user = new User(1,"zhangsan","123");
     * insert into User(userId,userName,userPass) values('1','zhangsan','123');
     * save(user)
     * @param obj
     */
    public static void save(Object obj) throws Exception{
        StringBuffer sb = new StringBuffer("insert into ");
        Class clazz = obj.getClass();
        String className = clazz.getSimpleName();
        sb.append(className+"(");// insert into User (
        Field[] fs = clazz.getDeclaredFields();//获取所有的属性信息
        for (Field field : fs) {
            String fieldName = field.getName();
            sb.append(fieldName+",");
        }//insert into User(userId,userName,userPass,
        sb.replace(sb.length()-1, sb.length(), ")");//insert into User(userId,userName,userPass)
        sb.append("values (");//insert into User(userId,userName,userPass) values (
        for (Field field : fs) {
            String  fieldName = field.getName();//属性名称
            String getterMethodName = makeGetter(fieldName);//根据属性名称获取getter方法名
            Method getterMethod = clazz.getDeclaredMethod(getterMethodName, null);//获取该属性对应getter方法
            Object value = getterMethod.invoke(obj, null);//回调getter方法获取对应的属性值
            sb.append("'"+value+"',");
        }//insert into User(userId,userName,userPass) values('1','zhangsan','123',
        sb.replace(sb.length()-1, sb.length(), ")");//insert into User(userId,userName,userPass) values('1','zhangsan','123')
        System.out.println(sb);
    }
    /**
     * 根据属性名称生成对应的getter方法名: get+属性的第一个字母大写+其余字母
     * @param fieldName  userId userName
     * @return   getUserId   getUserName
     */
    public static String makeGetter(String fieldName){
        return "get"+fieldName.substring(0, 1).toUpperCase()+fieldName.substring(1);
    }
    
    public static void main(String[] args) throws Exception {
        User user = new User(2,"lisi","123");
        MyHibernate.save(user);
        Student stu = new Student(1,"wangwu",23);
        MyHibernate.save(stu);
    }
    
}

public class Student implements Serializable{
    private int stuId;
    private String stuName;
    private int stuAge;
    
    public Student(int stuId, String stuName, int stuAge) {
        super();
        this.stuId = stuId;
        this.stuName = stuName;
        this.stuAge = stuAge;
    }

    public Student(){
        
    }

    public int getStuId() {
        return stuId;
    }

    public void setStuId(int stuId) {
        this.stuId = stuId;
    }

    public String getStuName() {
        return stuName;
    }

    public void setStuName(String stuName) {
        this.stuName = stuName;
    }

    public int getStuAge() {
        return stuAge;
    }

    public void setStuAge(int stuAge) {
        this.stuAge = stuAge;
    }
    
}

public interface Servlet {
    public void service();
}

/**
 * 用于封装web.xml中的servlet节点的信息
 * @author Administrator
 *
 */
public class ServletBean {
    private String name;//封装servlet-name的值
    private String clazz;//封装servlet-class的值
    
    public ServletBean(String name, String clazz) {
        super();
        this.name = name;
        this.clazz = clazz;
    }
    
    public ServletBean() {
        super();
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getClazz() {
        return clazz;
    }
    public void setClazz(String clazz) {
        this.clazz = clazz;
    }
    
}

public class IndexServlet implements Servlet {

    @Override
    public void service() {
        System.out.println("欢迎访问主页!");
    }

}

public class LoginServlet implements Servlet {

    @Override
    public void service() {
        System.out.println("用户登陆的service方法....");
    }

}

public class LogoutServlet implements Servlet {

    @Override
    public void service() {
        System.out.println("用户退出登陆的service方法....");
    }

}

public class XMLUtils {
    /**
     * 解析指定的XML，并将解析的结果保存到Map中返回，
     * 以配置文件的servlet-name中的文本做键,以配置文件servlet-class文本做值
     * @param file
     * @return
     */
    public static Map<String,String> paserXML(File file){
        Map<String,String> map = new HashMap<String,String>();//保存解析的web.xml中节点信息，用servlet-name做键，用servlet-class做值
        SAXReader saxReader = new SAXReader();
        try {
            Document document = saxReader.read(file);
            Element root = document.getRootElement();//获取web.xml中的根节点 webapps
            Iterator<Element> serlvetIter=  root.elementIterator();//获取根节点的子节点迭代器
            while(serlvetIter.hasNext()){
                ServletBean servletBean = new ServletBean();
                Element servletEle = serlvetIter.next();//获取servlet节点
                Iterator<Element> servletChildIter = servletEle.elementIterator();
                while(servletChildIter.hasNext()){
                    Element childEle = servletChildIter.next();//获取servlet的子节点 servlet-name, servlet-class
                    String elementName = childEle.getName();//获取元素的名称
                    String text = childEle.getText();
                    if("servlet-name".equals(elementName)){
                        servletBean.setName(text);
                    }else{
                        servletBean.setClazz(text);
                    }
                }
                map.put(servletBean.getName(), servletBean.getClazz());
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }
        return map;
    }
    
    public static void main(String[] args) {
        Map map = paserXML(new File("web.xml"));
        System.out.println(map);
    }
}

public class Test {
    /**
     * 违反了"开闭原则"
     * "开":对扩展要"开"--->程序应该容易扩展
     * "闭":对修改要"闭"--->尽可能少的修改代码或不修改代码
     */
    public static void main(String[] args) {
        Map<String,String> map = XMLUtils.paserXML(new File("web.xml"));
        System.out.println("请输入需要访问的Servlet名称");
        Scanner input = new Scanner(System.in);
        String servletName = input.nextLine();
//        if("LoginServlet".equals(servletName)){
//            LoginServlet loginServlet = new LoginServlet();
//            loginServlet.service();
//        }else if("LogoutServlet".equals(servletName)){
//            LogoutServlet logoutServlet = new LogoutServlet();
//            logoutServlet.service();
//        }else if("IndexServlet".equals(servletName)){
//            IndexServlet indexServlet = new IndexServlet();
//            indexServlet.service();
//        }
        String serlvetClass = map.get(servletName);
        //通过反射机制创建对象
        try {
            Servlet servlet = (Servlet)Class.forName(serlvetClass).newInstance();
            servlet.service();//多态
        } catch (Exception e) {
            e.printStackTrace();
        }
        
    }
}