java22

public class Test {
    public static void main(String[] args) {
        Student s = new Student();
        Map<String,String> mapping = s.getMapping();
        mapping.put("/login", "login");
        mapping.put("/log", "login");
        mapping.put("/reg", "register");//这样这个s里面的mapping也有值了。
        Student s1 = s;
        s1.setName("ererer");//s里面的name也有值了。
        System.out.println(s.getName());//ererer
        System.out.println(s1 == s);//true
        Teacher t = s.getTeacher();//t和s里面的teacher是同一个，地址是相同的。
        t.setName("teacher");
        t.setId("eee");//这样这个s里面的teacher也有值了。
        System.out.println(s.getTeacher().getName());
        System.out.println(s.getTeacher().getId());
        System.out.println(t==s.getTeacher());//true
    }

    
服务器新版本：
/**
 * 创建服务器，并启动
 * 
 * 1、请求
 * 2、响应
 */
public class Server {
    private ServerSocket server;
    public static final String CRLF="\r\n";
    public static final String BLANK=" ";
    
    private boolean isShutDown= false;
    public static void main(String[] args) {
        Server server = new Server();
        server.start();
    }
    /**
     * 启动方法
     */
    public void start(){        
        start(8888);
    }
    /**
     * 指定端口的启动方法
     */
    public void start(int port){        
        try {
            server = new ServerSocket(port);
            this.receive();
        } catch (IOException e) {
            stop();
        }
    }
    /**
     * 接收客户端
     */
    private void receive(){
        try {
            while(!isShutDown){
                new Thread(new Dispatcher(server.accept())).start();
            }
        } catch (IOException e) {
            stop();
        }
    }
    
    /**
     * 停止服务器
     */
    public void stop(){
        isShutDown=true;
        CloseUtil.closeSocket(server);
    }
}


/**
 * 一个请求与响应 就一个此对象
 */
public class Dispatcher implements Runnable{
    private Socket client;
    private Request req;
    private Response rep;
    private int code=200;
    Dispatcher(Socket client){
        this.client=client;
        try {
            req =new Request(client.getInputStream());
            rep =new Response(client.getOutputStream());
        } catch (IOException e) {
            code =500;
            return ;
        }
    }
    @Override
    public void run() {
        try {
            Servlet serv =WebApp.getServlet(req.getUrl());//用到此处的WebApp时会去加载WebApp的静态代码快。
            if(null==serv){
                this.code=404; //找不到处理
            }else{
                serv.service(req, rep);
            }
            rep.pushToClient(code); //推送到客户端
        }catch (Exception e) {
            e.printStackTrace();
            this.code=500;
        }    
        try {
            rep.pushToClient(500);
        } catch (IOException e) {
            e.printStackTrace();
        }
        req.close();
        rep.close();        
        CloseUtil.closeSocket(client);
    }
}



public class WebApp {
    private static ServletContext contxt;
    static{
        contxt = new ServletContext();
        
        Map<String,String> mapping = contxt.getMapping();
        mapping.put("/login", "login");//这样这个context里面的mapping也有了。
        mapping.put("/log", "login");
        mapping.put("/reg", "register");
        
        Map<String,Servlet> servlet = contxt.getServlet();
        servlet.put("login", new LoginServlet());
        servlet.put("register", new RegisterServlet());
    }
    
    public static Servlet getServlet(String url){
        if((null == url)||(url = url.trim()).equals("")){
            return null;
        }
        return contxt.getServlet().get(contxt.getMapping().get(url));
    }
}


/**
 * 上下文，就是一个容器。
 */
public class ServletContext {
    //为每一个servlet取个别名 ，login的Servlet名字为 LoginServlet
    private Map<String,Servlet> servlet;
    //url -->servlet的名字，例如/log -->login、/login -->login
    //由于多个路径可能对应一个Servlet，为了避免代码的重复所以要用一个map来存储Servlet和Servlet的名字。否则多个路径对应一个Servlet也写在这里，而对象占用的内存大也会很耗内存。
    private Map<String,String> mapping;
    
    ServletContext(){
        servlet =new HashMap<String,Servlet>();
        mapping =new HashMap<String,String>();
    }
    
    public Map<String, Servlet> getServlet() {
        return servlet;
    }
    public void setServlet(Map<String, Servlet> servlet) {
        this.servlet = servlet;
    }
    public Map<String, String> getMapping() {
        return mapping;
    }
    public void setMapping(Map<String, String> mapping) {
        this.mapping = mapping;
    }
}


/**
 * 抽象为一个父类
 */
public abstract class Servlet {
    public void service(Request req,Response rep) throws Exception{
        this.doGet(req,rep);
        this.doPost(req,rep);
    }
    public abstract void doGet(Request req,Response rep) throws Exception;
    public abstract void doPost(Request req,Response rep) throws Exception;
}




public class LoginServlet extends Servlet{
    @Override
    public void doGet(Request req,Response rep) throws Exception {
        String name = req.getParameter("uname");
        String pwd =req.getParameter("pwd");
        if(login(name,pwd)){
            rep.println("登录成功");
        }else{
            rep.println("登录失败");
        }
    }
    
    public boolean login(String name,String pwd){
        return name.equals("bjsxt") && pwd.equals("12346");
    }
    
    @Override
    public void doPost(Request req,Response rep) throws Exception {
    }
}

public class RegisterServlet extends Servlet{
    @Override
    public void doGet(Request req,Response rep) throws Exception {
    }
    
    @Override
    public void doPost(Request req,Response rep) throws Exception {
        rep.println("<html><head><title>返回注册</title>");
        rep.println("</head><body>");
        rep.println("你的用户名为:"+req.getParameter("uname"));
        rep.println("</body></html>");
    }
}


/**
 * 封装request
 * 处理请求信息
 *
 */
public class Request {
    //请求方式
    private String method;
    //请求资源
    private String url;
    //请求参数
    private Map<String,List<String>> parameterMapValues;
    //内部
    public static final String CRLF="\r\n";
    private InputStream is;
    private String requestInfo;
    public Request(){
        method ="";
        url ="";
        parameterMapValues=new HashMap<String,List<String>>();
        requestInfo="";
    }
    public Request(InputStream is){
        this();
        this.is=is;
        try {
            byte[] data = new byte[20480];
            int len = is.read(data);
            requestInfo = new String(data, 0, len);//读取浏览器发送的请求参数信息
        } catch (Exception e) {
            return ;
        }
        //分析请求信息
        parseRequestInfo();
    }
    /**
     * 分析请求信息
     */
    private void parseRequestInfo(){
        if(null==requestInfo ||(requestInfo=requestInfo.trim()).equals("")){
            return ;
        }        
        /**
         * =====================================
         * 从信息的首行分解出 :请求方式    请求路径   请求参数(get可能存在)
         *   如:GET /index.html?name=123&pwd=5456 HTTP/1.1
         * 
         * 如果为post方式，请求参数可能在 最后正文中
         * 
         * 思路:
         * 1)请求方式 :找出第一个/  截取即可
         * 2)请求资源:找出第一个/   HTTP/ 
         * =====================================
         */
        String paramString =""; //接收请求参数 
        //1、获取请求方式
        String firstLine =requestInfo.substring(0,requestInfo.indexOf(CRLF));
        int idx =requestInfo.indexOf("/"); // /的位置
        this.method=firstLine.substring(0, idx).trim();
        String urlStr =firstLine.substring(idx,firstLine.indexOf("HTTP/")).trim();
        if(this.method.equalsIgnoreCase("post")){
            this.url=urlStr;        
            paramString=requestInfo.substring(requestInfo.lastIndexOf(CRLF)).trim();
        }else if(this.method.equalsIgnoreCase("get")){
            if(urlStr.contains("?")){ //是否存在参数
                String[] urlArray=urlStr.split("\\?");
                this.url=urlArray[0];
                paramString=urlArray[1];//接收请求参数 
            }else{
                this.url=urlStr;            
            }
        }
        //不存在请求参数
        if(paramString.equals("")){
            return ;
        }
        //2、将请求参数封装到Map中    
        parseParams(paramString);
    }
    private void parseParams(String paramString){
        //分割 将字符串转成数组
        StringTokenizer token=new StringTokenizer(paramString,"&");
        while(token.hasMoreTokens()){
            String keyValue =token.nextToken();
            String[] keyValues=keyValue.split("=");
            if(keyValues.length==1){
                keyValues =Arrays.copyOf(keyValues, 2);
                keyValues[1] =null;
            }
            String key = keyValues[0].trim();
            String value = null==keyValues[1]?null:decode(keyValues[1].trim(),"gbk");
            //转换成Map 分拣
            if(!parameterMapValues.containsKey(key)){
                parameterMapValues.put(key,new ArrayList<String>());
            }
            List<String> values =parameterMapValues.get(key);
            values.add(value);            
        }        
    }
    /**
     * 解决中文
     * @param value
     * @param code
     * @return
     */
    private String decode(String value,String code){
        try {
            return java.net.URLDecoder.decode(value, code);
        } catch (UnsupportedEncodingException e) {
            //e.printStackTrace();
        }
        return null;
    }
    /**
     * 根据页面的name 获取对应的多个值
     * @param args
     */
    public String[] getParameterValues(String name){
        List<String> values=null;
        if((values=parameterMapValues.get(name))==null){
            return null;
        }else{
            return values.toArray(new String[0]);
        }
    }
    /**
     * 根据页面的name 获取对应的单个值
     * @param args
     */
    public String getParameter(String name){
        String[] values =getParameterValues(name);
        if(null==values){
            return null;
        }
        return values[0];
    }
    public String getUrl() {
        return url;
    }
    
    public void close(){
        CloseUtil.closeIO(is);
    }
}



/**
 * 封装响应信息
 * 组装一个符合http规范的字符串然后推出到浏览器
 *
 */
public class Response {
    //两个常量
    public static final String CRLF="\r\n";
    public static final String BLANK=" ";
    //流
    private BufferedWriter bw ;
    
    //正文
    private StringBuilder content;
    
    
    //存储头信息
    private StringBuilder headInfo;
    //存储正文长度
    private int len =0;
    public Response(){
        headInfo =new StringBuilder();
        content =new StringBuilder();
        len =0;
    }
    public Response(Socket client){
        this();
        try {
            bw= new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));
        } catch (IOException e) {
            headInfo=null;
        }
    }
    public Response(OutputStream os){
        this();
        bw= new BufferedWriter(new OutputStreamWriter(os));
    }
    /**
     * 构建正文
     */
    public Response print(String info){
        content.append(info);
        len+=info.getBytes().length;
        return this;
    }
    
    /**
     * 构建正文+回车
     */
    public Response println(String info){
        content.append(info).append(CRLF);
        len+=(info+CRLF).getBytes().length;
        return this;
    }
    
    /**
     * 构建响应头
     */
    private void createHeadInfo(int code){
        //1)  HTTP协议版本、状态代码、描述
        headInfo.append("HTTP/1.1").append(BLANK).append(code).append(BLANK);
        switch(code){
            case 200:
                headInfo.append("OK");
                break;
            case 404:
                headInfo.append("NOT FOUND");
                break;
            case 505:
                headInfo.append("SEVER ERROR");
                break;    
        }
        headInfo.append(CRLF);
        //2)  响应头(Response Head)
        headInfo.append("Server:bjsxt Server/0.0.1").append(CRLF);
        headInfo.append("Date:").append(new Date()).append(CRLF);
        headInfo.append("Content-type:text/html;charset=GBK").append(CRLF);
        //正文长度 ：字节长度
        headInfo.append("Content-Length:").append(len).append(CRLF);
        headInfo.append(CRLF); //分隔符
    } 
    //推送到客户端
    void pushToClient(int code) throws IOException{
        if(null==headInfo){
            code =500;
        }
        createHeadInfo(code);
        //头信息+分割符
        bw.append(headInfo.toString());
        //正文
        bw.append(content.toString());
        bw.flush();//推出到浏览器，这样浏览器就可以正常显示了。
    }
    public void close(){
        CloseUtil.closeIO(bw);
    }
}





反射
-动态语言：在运行期间随意的改变对象的类型+结构 ,例如ruby js
-Java不是动态语言，但具有动态属性（反射）
1.反射 镜子（反射理解为保留了类的字节码信息，）
1）原来是在编译的时候创建对象，现在是在运行的时候创建对象，
2）jvm在创建的时自动生成与之对应的Class对象，同一个类的多个对象在jvm只有一个对应的class文件。
2.Class
1）可以看成类的元数据，每一个对象在创建是jvm会自动生成与之对应的Class，同类型的对象对应一个Class。
2）获取Class对象的3种方式：对象.getClass()、类.class(Student.class)、Class.forName("完整类名")。



/**
 * 获取结构信息Class对象(源头)
 */
public class Demo01 {
    public static void main(String[] args) throws ClassNotFoundException {
        String  str ="abc";
        //Class对象
        //对象.getClass()
        Class<?> clz =str.getClass();//class java.lang.String
        //类.class
        clz =String.class;//class java.lang.String
        //完整路径
        clz=Class.forName("java.lang.String");//class java.lang.String
    }
}



/**
 * 创建实例  调用空构造
 */
public class Demo02 {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        Class<?> clz =Class.forName("com.bjsxt.server.demo3.LoginServlet");//clz=class com.bjsxt.server.demo3.LoginServlet
        // 调用空构造 确保空构造存在
        Servlet ser=(Servlet)clz.newInstance(); //返回Object,会有强制类型转换，ser=com.bjsxt.server.demo3.LoginServlet@a61164
        //retrun ser;
    }
}




public class WebApp {
    private static ServletContext contxt;
    static{
        contxt =new ServletContext();
        
        Map<String,String> mapping =contxt.getMapping();
        mapping.put("/login", "login");
        mapping.put("/log", "login");
        mapping.put("/reg", "register");
        
        Map<String,String> servlet =contxt.getServlet();
        servlet.put("login", "com.bjsxt.server.demo3.LoginServlet");
        servlet.put("register", "com.bjsxt.server.demo3.RegisterServlet");
    }
    
    public static Servlet getServlet(String url) throws InstantiationException, IllegalAccessException, ClassNotFoundException{
        if((null==url)||(url=url.trim()).equals("")){
            return null;
        }
        //根据字符串(类完整路径)创建对象
        
        String name=contxt.getServlet().get(contxt.getMapping().get(url));
        return (Servlet)Class.forName(name).newInstance();//确保空构造存在
    }
}