java学习笔记—实现一个类MyInputStream(28)

1 实现一个类MyInputStream读取文件,且不能抛出异常

public class TestDemo {
    public static void main(String[] args) throws Exception {
        InputStream in = new MyInputStream("d:/a/a.txt");
        byte[] b = new byte[1024];
        int len = 0;
        while((len=in.read(b))!=-1){
            String s = new String(b,0,len);
            System.err.print(s);
        }
        in.close();
    }
}
class MyInputStream extends InputStream {  //成为inputstream的子类,即is a.
    private InputStream in;
    public MyInputStream(String fileName) {
        try {
            in = new FileInputStream(fileName);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
    public int read(byte[] b){
        int len=-1;
        try {
            len = in .read(b);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return len;
    }
    public void close(){
        try {
            in.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    @Override
    public int read() throws IOException {
        return 0;
    }
}

2 以下通过包装[W1] 实现对close方法的修改,以回收连接

1:实现Connection接口,拥有一个Connection的成员。

 2:修改close方法。

 3:其他的方法都调用成员变量的connection。

public class MyDataSource implements DataSource  {
    private LinkedList<Connection> pool = new LinkedList<Connection>();
    public MyDataSource() {
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String url = "jdbc:mysql:///db909?characterEncoding=UTf8";
            for (int i = 0; i < 3; i++) {
                //创建原生的连接,// [email protected]
                Connection con = DriverManager.getConnection(url, "root",
                        "1234");
                //声明包装类
                MyConn conn = new MyConn(con);
                pool.add(conn);//将包装类添加到池中去
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //此方法来自于datasource,用于返回一个连接
    public Connection getConnection()  throws SQLException {
        synchronized (pool) {
            if (pool.size() == 0) {
                try {
                    pool.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                return getConnection();
            }
            Connection con = pool.removeFirst();
            System.err.println("siize:" + pool.size());
            return con;
        }
    }

以下包装connection

class MyConn implements Connection  {
        // 声明被包装类的成员
        private Connection conn; //[email protected]

        // 通过构造接收MySql的connection的对象[email protected]
        public MyConn(Connection con) {
            this.conn = con;
        }
         //关闭连接
        public void close() throws SQLException {
            synchronized (pool) {
                //有人调用了关闭方法,不能关
                System.err.println("有人还连接了。。。。"+this);
                pool.add(this);
                pool.notify();
            }
        }
}

3、用包装处理get方式的乱码

package cn.itcast.utils;
import java.io.IOException;
import java.lang.reflect.Method;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
public class BaseServlet extends HttpServlet {
    @Override
    public void service(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        req.setCharacterEncoding("UTF-8");
        String methodName = req.getParameter("cmd");
        try{
            Method mm = this.getClass().getMethod(methodName,HttpServletRequest.class,HttpServletResponse.class);
            //声明包装类
            MyRequest mr = new MyRequest(req);
            mm.invoke(this,mr,resp);
        }catch(Exception e){
            e.printStackTrace();
        }
    }
}
//包装request
class MyRequest extends HttpServletRequestWrapper{
    private HttpServletRequest req;
    public MyRequest(HttpServletRequest request) {
        super(request);
        this.req=request;
    }
    //修改getparameter方法
    @Override
    public String getParameter(String name) {
        String value = req.getParameter(name);
        if(req.getMethod().equals("GET")){
            System.err.println("转码");
            try{
                value = new String(value.getBytes("ISO-8859-1"),"UTF-8");
            }catch(Exception e){
            }
        }
        return value;
    }
}

总结:

1:代理或是包装都是对某个类的方法进行增强。

代理:必须要根据给定的接口,在内存中创建这个接口的子类。$Proxy0。

包装:不需要接口,但声明声明一个类,变成被包装类的子类,同时拥有一个被包装类的成员。

2:代理基本代码:

Object proxyedObj =

Proxy.newProxyInstance(ClassLoader,

New class[]{被代理的类的接口数组.class},

New InvocationHandler(){//执行句柄

Public Object invode(Object 代理,Method 方法反射,object[] args){

Reutrn method.invode(被代理类,args);

}

}

3:包装:

如果一个类是某个类的包装类,则:

A extends B{

Privet B b;

}

4:什么情况下,使用包装,什么情况下使用代理

如果官方(SUN)提供了包装类适配器,则应该优先使用包装。如HttpServletRequest,它的包装类就是HtpServletRequestWraper.

如果官方没有提供包装类的适配器,则可以使用动态代理。如Connection。

时间: 2024-10-09 08:40:08

java学习笔记—实现一个类MyInputStream(28)的相关文章

非专业码农 JAVA学习笔记 6java工具类和算法-string

续<非专业码农 JAVA学习笔记 5 java工具类和算法> 五.字符串string 字符串和字符的差别:字符串双引号括起来”n”,字符用单引号括起来,表示一种符号’\n’ 1.string的主要方法和属性 类 方法或者属性 备注 定义string Stirng s=new string(“值”),string s=”值” 属性 string.length:string的长度为字节 方法startswith,endswith s.startwith(“值”)-以值为开头,s.endswith(

java学习笔记7--抽象类与抽象方法

1.终结类与终结方法 被final修饰符修饰的类和方法,终结类不能被继承,终结方法不能被当前类的子类重写 终结类的特点:不能有派生类 终结类存在的理由: 安全: 黑客用来搅乱系统的一个手法是建立一个类的派生类,然后用他们的类代替原来的类 设计: 你认为你的类是最好的或从概念上你的类不应该有任何派生类 终结方法的特点:不能被派生类覆盖 终结方法存在的理由: 对于一些比较重要且不希望子类进行更改的方法,可以声明为终结方法.可防止子类对父类关键方法的错误重写,增加了代码的安全性和正确性 提高运行效率.

【原】Java学习笔记031 - 常用类

1 package cn.temptation; 2 3 public class Sample01 { 4 public static void main(String[] args) { 5 /* 6 * 类 Math:包含用于执行基本数学运算的方法,如初等指数.对数.平方根和三角函数. 7 * 8 * Math类的常用字段: 9 * static double E :比任何其他值都更接近 e(即自然对数的底数)的 double 值. 10 * static double PI :比任何其他

Java学习笔记--第一个Hibernate框架程序

程序结构 1.建表 本例选择Sql Server2008作为数据库 在MySQL中新增一个ztest数据库,建立 CUSTOMER 表 CREATE TABLE CUSTOMER ( CID INTEGER NOT NULL PRIMARY KEY, USERNAME VARCHAR(12) NOT NULL, PASSWORD VARCHAR(12) ); 2.创建PO对象 补充:POJO是Plain OrdinaryJava Object的缩写,它通指没有使用Entity Beans的普通j

黑马程序员——JAVA学习笔记七(String类)

1,    String类一旦被初始化就不会被改变. 字符串不不能被改变,编译可以让字符串之间共享.编译器将各种字符串存放在公共的存储池子中.字符串变量指向存储池中相应的位置.实际上只有字符串常量.而+(除了常量相加)和其它方法操作的不是共享的. String s1 ="abc" ,String s2 = "abc" (他们存在公共池中),String s3 = new String ("abc"),存在堆中; 则s1== s2; s1! = s

java学习笔记之Arrays类(二分查找)

import java.io.*; import java.util.*; import java.math.*; import java.text.*; public class Main { public static void main(String[] args){ Scanner in=new Scanner(System.in); int x,n; while(in.hasNext()){ n=in.nextInt(); int[] a=new int[n]; for(int i=0

java学习笔记10--泛型总结

java学习笔记系列: java学习笔记9--内部类总结 java学习笔记8--接口总结 java学习笔记7--抽象类与抽象方法 java学习笔记6--类的继承.Object类 java学习笔记5--类的方法 java学习笔记4--对象的初始化与回收 java学习笔记3--类与对象的基础 java学习笔记2--数据类型.数组 java学习笔记1--开发环境平台总结 本文地址:http://www.cnblogs.com/archimedes/p/java-study-note10.html,转载

java学习笔记8--接口总结

接着前面的学习: java学习笔记7--抽象类与抽象方法 java学习笔记6--类的继承.Object类 java学习笔记5--类的方法 java学习笔记4--对象的初始化与回收 java学习笔记3--类与对象的基础 java学习笔记2--数据类型.数组 java学习笔记1--开发环境平台总结 本文地址:http://www.cnblogs.com/archimedes/p/java-study-note8.html,转载请注明源地址. 生活中的接口: 什么是接口? 一个Java接口是一些方法特

java学习笔记14--多线程编程基础1

本文地址:http://www.cnblogs.com/archimedes/p/java-study-note14.html,转载请注明源地址. 多线程编程基础 多进程 一个独立程序的每一次运行称为一个进程,例如:用字处理软件编辑文稿时,同时打开mp3播放程序听音乐,这两个独立的程序在同时运行,称为两个进程 进程要占用相当一部分处理器时间和内存资源 进程具有独立的内存空间 通信很不方便,编程模型比较复杂 多线程 一个程序中多段代码同时并发执行,称为多线程,线程比进程开销小,协作和数据交换容易