Junit是由 Erich Gamma 和 Kent Beck 编写的一个回归测试框架（regression testing framework）。Junit是一套框架，继承TestCase类，就可以用Junit进行自动测试了。

1 junit特性

junit

Junit是一个开放源代码的Java测试框架，用于编写和运行可重复的测试。他是用于单元测试框架体系xUnit的一个实例（用于java语言）。它包括以下特性：

　　① 用于测试期望结果的断言（Assertion）

　　② 用于共享共同测试数据的测试工具

　　③ 用于方便的组织和运行测试的测试套件

④ 图形和文本的测试运行器

 
2 Eclipse中配置Junit

右击要使用的junit的项目，点击properties—java bulid path-libraries，点击Add External JARs,加上JUNIT包。

 3 用法

- 创建，从junit.framework.TestCase派生nuit test需要的test case.

- 书写测试方法

- 编译 书写玩test case后，编译所写的test case类

- 运行，启动junit test runnner 来运行这个test case。

实例代码：

package com.dr.test;

import java.util.List;

import junit.framework.TestCase;

import com.dr.dao.StudentDao;

import com.dr.dao.impl.StudentDaoImpl;

import com.dr.vo.Student;

public class StudentDaoImplTest extends TestCase{

    StudentDao dao;

    protected void setUp() throws Exception{

       dao=new StudentDaoImpl();

    }

    protected void tearDown() throws Exception{

    }

    public void testAdd(){

       Student stu=new Student();

       stu.setName("ling");

       stu.setAge(1);

       stu.setEmail("ling@126.com");

       dao.addStudent(stu);

    }

    public void testListStudent(){

       List<Student> list=dao.getStudentList();

       System.out.println(list.size());

    }

}

Junit中的两个函数：setUp与tearDown,是junit framework中提供初始化金额反初始化每个测试方法的。setUp在每个测试方法调用前被调用，负责初始化测试方法所需要的测试环境；teardown在每个测试方法被调用之后被调用，负责撤销测试环境。

测试结果：

在JUnit的窗口中显示了一个绿条，绿条证明测试成功。

ServletContextListener监听ServletContext。当创建ServletContext时，激发 contextInitialized(ServletContextEvent sce)方法；当销毁ServletContext时，激发contextDestroyed(ServletContextEvent sce)方法。

ServletContextAttributeListener监听对ServletContext属性的操作，比如增加、删除、修改属性。

HttpSessionListener监听HttpSession的操作。当创建一个Session时，激发session Created(HttpSessionEvent se)方法；当销毁一个Session时，激发sessionDestroyed (HttpSessionEvent se)方法。

HttpSessionAttributeListener监听HttpSession中的属性的操作。当在Session增加一个属性时，激发 attributeAdded(HttpSessionBindingEvent se) 方法；当在Session删除一个属性时，激发attributeRemoved(HttpSessionBindingEvent se)方法；当在Session属性被重新设置时，激发attributeReplaced(HttpSessionBindingEvent se) 方法。

下面我们开发一个具体的例子，这个监听器能够统计在线的人数。

程序源代码：

package com.dr.web.listener;

import javax.servlet.ServletContext;

import javax.servlet.ServletContextEvent;

import javax.servlet.ServletContextListener;

import javax.servlet.http.HttpSessionEvent;

import javax.servlet.http.HttpSessionListener;

publicclass UserCountListener implements ServletContextListener,

       HttpSessionListener {

    //每个web应用都有且仅有一个ServletContext对象，这个对象在所有的Servlet都可以使用。

    /**

     * 因为一个web应用就一个ServletContext 对象，因此可以使用ServletContext 来做一些全局性的属性设置等。

     * 比如网站访问计数器等等

     *

     *

     * ServletContext 是一个应用程序与Web容器(tomcat之类)交互的接口,同时它也是管理应用程序资源的对象，

                                                   通过它可以读取web.xml中一些配置，如<context-param>中的信息，读取应用中的资源等。

       Session 是一个会话对象，也就是说当客户端访问服务器页面时，它才产生，

                                        原理是服务器对每个客户端产生一个sessionid值,并把它也保存在客户端，

                                        每次请求时验证这个sessionid是否是创建了sessionid的客户端，在服务器端对应这个sessionid会创建一个缓存区，

                                        存储一些相关信息,程序员可以操作，如被用于购物车，存储用户信息等，这个区域只有对特定用户有访问权限，对其他客户是拒绝访问的，这就是一个会话。

       Request 是一个请求对象，也就是说它的生命很短暂，只在一个请求中存在，如一个页面到另一个页面，

                                     一个页面到servlet或action,一个servlet或action到jsp页面等,你可以用它的setAttribute方法传递需要的信息(对象),验证请求方的信息,获得请求方发过来的文件内容等。

     */

    private ServletContext sc;

    publicvoid contextDestroyed(ServletContextEvent arg0) {

    }

    publicvoid contextInitialized(ServletContextEvent event) {

       ServletContext sc = event.getServletContext();

       sc.setAttribute("Users", new Integer(0));

       this.sc = sc;

    }

    publicvoid sessionCreated(HttpSessionEvent event) {//在线

       System.out.println("new user login our web site");

       Integer users = (Integer)sc.getAttribute("Users");

       sc.setAttribute("Users", ++users);

    }

    publicvoid sessionDestroyed(HttpSessionEvent event) {

       Integer users = (Integer)sc.getAttribute("Users");

       sc.setAttribute("Users", --users);

    }

}

Web.xml中配置如下：

    <listener>

       <listener-class>com.dr.web.listener.UserCountListener</listener-class>

    </listener>

在UserCountListener里，用users代表当前在线的人数，UserCountListener将在Web服务器启动时自动执行。当UserCountListener构造好后，把users设置为 0。每增加一个Session，UserCountListener会自动调用sessionCreated(HttpSessionEvent event)方法；每销毁一个Session，UserCountListener会自动调用 sessionDestroyed(HttpSessionEvent se)方法。当调用sessionCreated(HttpSessionEvent event)方法时，说明又有一个客户在请求，此时使在线的人数（users）加1，并且把user写到ServletContext中。 ServletContext的信息是所有客户端共享的，这样，每个客户端都可以读取到当前在线的人数。

运行结果：

过滤器代码：

package com.dr.course;

import java.io.IOException;

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.HttpSession;

import com.dr.common.Global;

import com.dr.vo.User;

public class IsLoginFilter implements Filter {

       public void destroy() {

       }

       public void doFilter(ServletRequest request, ServletResponse response,

                     FilterChain filterChain) throws IOException, ServletException {

              System.out.println("every request pass here");

              HttpServletRequest hrequest=(HttpServletRequest)request;

              HttpSession session=hrequest.getSession();

              User user =     (User)session.getAttribute(Global.USER);

              if(user == null){

                     //跳转到登陆页面

            hrequest.getRequestDispatcher("/index.jsp").forward(request,response);                 

              }

              filterChain.doFilter(request, response);

       }

       public void init(FilterConfig filterConfig) throws ServletException {

       }

}

LoginServlet类，进行登录之后的处理：

package com.dr.course;

import java.io.IOException;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

import com.dr.common.Global;

import com.dr.vo.User;

public class LoginServlet extends HttpServlet{

       public void doPost(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException{

              String userName=request.getParameter("username");

              String passWord=request.getParameter("password");

            System.out.println("userName | " + userName);

            System.out.println("passWord | " + passWord);

            User user = new User();

            user.setUserName(userName);

            user.setPassWord(passWord);

            HttpSession session = request.getSession();

            //登录成功，把User放到session，然后在拦截器中判断

            //key--value

            session.setAttribute(Global.USER, user);

            request.getRequestDispatcher("/admin/main.jsp").forward(request, response);

       }

}

web.xml中配置如下：

- <filter>

  <filter-name>isLogin</filter-name>

  <filter-class>com.dr.course.IsLoginFilter</filter-class>

  </filter>

- <filter-mapping>

  <filter-name>isLogin</filter-name>

  <url-pattern>/admin/*</url-pattern>

  </filter-mapping>

- <servlet>

  <servlet-name>login</servlet-name>

  <servlet-class>com.dr.course.LoginServlet</servlet-class>

  </servlet>

- <servlet-mapping>

  <servlet-name>login</servlet-name>

  <url-pattern>/login</url-pattern>

  </servlet-mapping>

 未登录界面：

成功登录的界面：

我们在登录126邮箱时，如果勾选上两周内自动登录，两周内不用输入用户名和密码邮箱会自动登录，这是因为第一次登录时服务器将用户名和密码写入cookie中，并返回给客户端。

下次登录时Http协议会带着用户的cookie去服务器验证，因为服务器已经存储用户的信息，所以会自动登录。

登录代码：

package com.dr.course;

import java.io.IOException;  

import javax.servlet.ServletException;  

import javax.servlet.http.Cookie;  

import javax.servlet.http.HttpServlet;  

import javax.servlet.http.HttpServletRequest;  

import javax.servlet.http.HttpServletResponse;  

public class LoginServlet extends HttpServlet {  

    public void doGet(HttpServletRequest request, HttpServletResponse response)  

            throws ServletException, IOException {  

        this.doPost(request, response);  

    }  

    public void doPost(HttpServletRequest request, HttpServletResponse response)  

            throws ServletException, IOException {  

           String username=request.getParameter("username");  

           String password=request.getParameter("password");  

           String savetime=request.getParameter("saveTime");  

           if(CheckLogin.login(username, password)){  

               if(null!=savetime){  

                   int saveTime=Integer.parseInt(savetime);//这里接受的表单值为天来计算的  

                   int seconds=saveTime*24*60*60;  

                   Cookie cookie = new Cookie("user", username+"=="+password);  

                   cookie.setMaxAge(seconds);                     

                   response.addCookie(cookie);  

               }  

               request.setAttribute("username",username);  

               request.getRequestDispatcher("/main126.jsp").forward(request,response);  

           }else{  

               request.getRequestDispatcher("/failure.jsp").forward(request,response);  

           }  

    }  

}  

验证代码：

package com.dr.course;

import java.io.IOException;  

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.Cookie;  

import javax.servlet.http.HttpServletRequest;  

import javax.servlet.http.HttpServletResponse;  

public class IndexFilter implements Filter {  

    public void destroy() {  

        // TODO Auto-generated method stub  

    }  

    public void doFilter(ServletRequest arg0, ServletResponse arg1,  

            FilterChain arg2) throws IOException, ServletException {

           System.out.println("every request pass here haha");

        HttpServletRequest request = (HttpServletRequest) arg0;  

        HttpServletResponse response = (HttpServletResponse) arg1;  

        Cookie[] cookies = request.getCookies();  

        String[] cooks = null;  

        String username = null;  

        String password = null;  

        if (cookies != null) {  

            for (Cookie coo : cookies) {  

                String aa = coo.getValue();  

                cooks = aa.split("==");  

                if (cooks.length == 2) {  

                    username = cooks[0];  

                    password = cooks[1];  

                }  

            }  

        }

        System.out.println("cookie username | " + username);

        System.out.println("cookie password | " + password);

        if (CheckLogin.login(username, password)) {

               System.err.println("check successfully cookie data ");

            request.getSession().setAttribute("username",username);  

            request.getRequestDispatcher("/main126.jsp").forward(request, response);

        }else{  

            arg2.doFilter(request,response );  

        }  

    }  

    public void init(FilterConfig arg0) throws ServletException {  

        // TODO Auto-generated method stub  

    }  

}

package com.dr.course;

public class CheckLogin {

        public static boolean login(String username, String password) {  

               if ("admin".equals(username) && "123456".equals(password)) {  

                   return true;  

               } else {  

                   return false;  

               }  

           }  

}

web.xml中配置如下：

- <filter>

 <filter-name>loginFilter</filter-name>

 <filter-class>com.dr.course.IndexFilter</filter-class>

 </filter>

- <filter-mapping>

 <filter-name>loginFilter</filter-name>

 <url-pattern>/main126.jsp</url-pattern>

 </filter-mapping>

- <servlet>

 <servlet-name>LoginServlet</servlet-name>

 <servlet-class>com.dr.course.LoginServlet</servlet-class>

 </servlet>

- <servlet-mapping>

 <servlet-name>LoginServlet</servlet-name>

 <url-pattern>/login.do</url-pattern>

 </servlet-mapping>

将目录加入到Tomcat中，开启Tomcat，打开浏览器输入网址:http://127.0.0.1:8080/AutoLogin/login.do进行测试。

为防止中文乱码出现，首先我们要把项目中每个网页的编码形式改成中文的，HTML网页中的charset改成UTF-8，JSP网页中的pageEncoding改成UTF-8。

然后我们做一个过滤器，每次对网页的请求都会进入到过滤器，并且把request和response都改成UTF-8编码形式，这样防止了中文乱码的出现。

源代码如下：

package com.dr.servletform;

import java.io.IOException;

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.jsp.jstl.core.Config;

public class MyFilter implements Filter{

       String encoding="";

       public void destroy() {

       }

       public void doFilter(ServletRequest request, ServletResponse response,

                     FilterChain chain) throws IOException, ServletException {

              System.out.println("pass here-------");

              request.setCharacterEncoding(encoding);

              response.setCharacterEncoding(encoding);

              chain.doFilter(request, response);

       }

       public void init(FilterConfig config) throws ServletException {

              String encoding=config.getInitParameter("encoding");

              this.encoding=encoding;

              System.out.println(encoding);

       }

}

web.xml中配置如下：

<filter>

 <filter-name>MyFilter</filter-name>

 <filter-class>com.dr.servletform.MyFilter</filter-class>

- <init-param>

 <param-name>encoding</param-name>

 <param-value>UTF-8</param-value>

 </init-param>

 </filter>

- <filter-mapping>

 <filter-name>MyFilter</filter-name>

 <url-pattern>/*</url-pattern>

 </filter-mapping>

JDBC编程步骤：

       加载数据库驱动（jar 文件）

       获得数据库连接

       创建语句 (SQL)

       执行查询

       遍历结果集

       关闭数据库连接

示例小程序：

package com.dr.jdbc;

/**

 * DriverManager 驱动程序管理器 在数据库和相应驱动程序之间建立连接

 * Connection 对象代表与数据库的连接，也就是在已经加载的Driver和数据库之间建立连接

 * Statement 提供在基层连接上运行SQL语句，并且访问结果

 * ResultSet 在Statement执行SQL语句时，有时会返回ResultSet结果集，包含的是查询的结果集

 */

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

public class Test {

    public static void main(String[] args) {   

            query();

    }   

    public static void query(){   

            Connection conn = null;   

            try {

                       //1.加载数据库驱动

                    Class.forName("com.mysql.jdbc.Driver");   

                    //2.获得数据库连接

                    //DriverManager 驱动程序管理器 在数据库和相应驱动程序之间建立连

                    conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/jdbc_db", "root", "1234"); 

                     //3.创建语句

                    String sql = "select * from UserTbl";   

                    //返回一个执行SQL的句柄

                    Statement stmt = conn.createStatement(); 

                    //返回查询的

                    //4.执行语句

                    ResultSet rs = stmt.executeQuery(sql);

                    //5.遍历结果集

                    while(rs.next()){   

                            int id = rs.getInt(1);   

                            String username = rs.getString(2);   

                            String password = rs.getString(3);   

                            int age = rs.getInt(4);   

                            System.out.println(id+":"+username+":"+password+":"+age);   

                    }   

            } catch (Exception e) {   

                    e.printStackTrace();   

            }finally{   

                    if(conn!=null){   

                            try {    //关闭数据库连接

                                    conn.close();   

                            } catch (SQLException e) {   

                                    conn = null;   

                                    e.printStackTrace();   

                            }   

                    }   

            }   

    }

}

package com.dr.Demo01;

import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerSocket01 {

 public static void main(String[] args) {
  ServerSocket server=null;
  try{
   //服务器在9999端口开辟了服务
   server=new ServerSocket(9999);
  }catch(Exception e){}
  //对于服务器而言，所有用户的请求都是通过SeverSocket实现
  Socket client=null;
  try{
   //服务器在此等待用户的链接
   System.out.println("等待客户端链接、、、");
   client=server.accept();//服务端接收到一个client
  }catch(Exception e){}
  //要向客户端打印信息
  PrintStream out=null;
  //得到向客户端输出信息的能力
  try{
   out=new PrintStream(client.getOutputStream());
  }catch(Exception e){}
  out.println("Hi,how do you do?");
  try{
   client.close();
   server.close();
  }catch(Exception e){}
  System.out.println("客户端回应完毕、、、");
 }

}

package com.dr.Demo01;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.Socket;

public class ClientSocket01 {

 public static void main(String[] args) {
 
  Socket client=null;
  try{
   //实际上表示要链接到服务器上去了
   client=new Socket("192.168.1.23",9999);
  }catch(Exception e){}
  //等待服务器端的回应
  String str=null;
  //如果直接使用InputStream接受会比较麻烦
  //最好的方法是可以把内容放入发哦缓冲流之中进行读取
  BufferedReader buf=null;
  
  try{
   buf=new BufferedReader(new InputStreamReader(client.getInputStream()));
      str=buf.readLine();
  }catch(Exception e){}
  System.out.println(str);
 }

}

程序有两种以外需要考虑：

1、      假设Benz线程刚向数据存储空间添加了一辆车的名字。还没有加入这辆车的颜色，CPU就切换到了BMW线程，Benz线程将把这辆车的名字和上辆车的颜色联系到了一起。

2、      Benz放了若干次的数据。BMW才开始取数据，或者是，BMW取完了一个数据后，还没等到Benz放入新的数据，又重复取出已取过的数据。

可能出现的问题：

1、      Benz比BMW快时，BMW会漏掉一些数据没有取到。

2、      BMW比Benz快时，BMW取相同的数据。

多个线程共享同一资源的时候，必须进行同步，采用同步方法，解决第一个问题。

线程的等待和唤醒机制：

wait()：告诉当前线程放弃监视器并进入睡眠状态，直到其他线程进入同一监视器并调用notify为止。

notify()：唤醒同一对象监视器中调用wait的第一个线程。

程序中采用线程的等待和唤醒机制，当发现BMW没有取走内容时，Benz应该等待，当BMW把内容取走之后，Benz才可以放。这样解决了第二个问题。

代码如下：

package com.dr.test;

class Car{

       private String name="奔驰";

       private String color="银色";

       private boolean flag=false;

       public synchronized void set(String name,String color){

              //如果flag的值不是true则要等待

              if(!flag){

                     //等待

                     try{

                            wait();

                     }catch(Exception e){}

              }

              //如果向下继续执行了，则表示可以设置，flag=true

              this.name=name;

              this.color=color;

              flag=false;

              notify();

       }

       public synchronized void get(){

              //如果flag的值为true的时候，表示要等待

              if(flag){

                     try{

                            wait();

                     }catch(Exception e){}

              }

              //如果向下执行了，则表示允许取出

              System.out.println(this.name+"-->"+this.color);

              //改变标志，表示可以生产了

              flag=true;

              notify();

       }

}

class Benz implements Runnable{

       Car car=null;

       public Benz(Car c){

              this.car=c;

       }

       public void run(){

              int i=0;

              while(true){

                     if(i==0){

                            car.set("宝马", "红色");

                            i=1;

                     }

                     else{

                            car.set("奔驰", "银色");

                            i=0;

                     }

              }

       }

}

class BMW implements Runnable{

       Car car=null;

       public BMW(Car c){

              this.car=c;

       }

       public void run(){

              while(true){

                     car.get();

              }

       }

}

public class Demo01 {

       public static void main(String[] args) {

              Car c=new Car();

              Benz benz=new Benz(c);

              BMW bmw=new BMW(c);

              new Thread(benz).start();

              new Thread(bmw).start();

       }

}

运行结果：

1 通过继承Thread类来实现。

每个线程都是通过某个特定Thread对象所对应的方法run()l来完成其操作的，方法run()成为线程体。

如果想要启动多线程，则肯定调用start()方法，start方法可以调用被子类覆写过的run方法

不过这种这种实现方式会受到单继承的局限

示例代码：

package com.dr.demo01;

//一个类只要继承了Thread类，则此类就是多线程类

class MyThread extends Thread{

       private String name;

       public MyThread(String name){

              this.name=name;

       }

       //如果要使用多线程，则必须有一个方法的主体

       public void run(){

              //打印输出

              for(int i=0;i<15;i++){

                     System.out.println(this.name+"--->在运行、、、");

              }

       }

}

public class ThreadDemo01{

       public static void main(String args[]){

              MyThread mt1=new MyThread("线程A");

              MyThread mt2=new MyThread("线程B");

              MyThread mt3=new MyThread("线程C");

              mt1.run();

              mt2.run();

              mt3.run();

       }

}

2 通过实现Runnable接口来实现。

该实现方式有以下好处：

①     适合多个相干同程序代码的线程去处理同一资源的情况。

②     可以避免由于Java单继承特性带来的局限。

③     有利于程序的健壮性，代码能够被多个线程共享。

示例代码：

package com.dr.Demo05;

class MyThread implements Runnable{

    public void run(){

       for(int i=0;i<100;i++){

           try{

              Thread.sleep(1000);

           }catch(Exception e){}

           System.out.println(Thread.currentThread().getName()+"--运行中--");

       }

    }

}

public class Demo05 {

    public static void main(String[] args) {

       MyThread mt=new MyThread();

       Thread t1=new Thread(mt,"线程A");

       Thread t2=new Thread(mt,"线程B");

       Thread t3=new Thread(mt,"线程C");

       t1.start();

       t2.start();

       t3.start();

    }

}