少年阿賓

package com.abin.lee.servlet.process;

import java.io.IOException;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class ProcessServlet extends HttpServlet{
 public void init() throws ServletException {
  super.init();
 }
 @SuppressWarnings("rawtypes")
 protected 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);
  
  ServletContext context = getServletContext();
  RequestDispatcher dispatcher = context.getNamedDispatcher("dispatcher");
  dispatcher.forward(request, response);

//  ServletOutputStream out=response.getOutputStream();
//  BufferedWriter writer=new BufferedWriter(new OutputStreamWriter(out));
//  writer.write("success");
//  writer.flush();
//  writer.close();
  
 }
 public void destroy() {
  super.destroy();
 }
}

package com.abin.lee.servlet.process;

import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringWriter;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import junit.framework.TestCase;

import org.easymock.EasyMock;
import org.junit.Before;
import org.junit.Test;
public class ServletMock extends TestCase{
 private static HttpServletRequest request =null;
 private static HttpServletResponse response=null;
 private static ServletContext context=null;
 private static RequestDispatcher dispatcher=null;
 private static ProcessServlet servlet=null;
 @Before
 public  void setUp(){
  request =EasyMock.createMock(HttpServletRequest.class);
  response=EasyMock.createMock(HttpServletResponse.class);
  context=EasyMock.createMock(ServletContext.class);
  dispatcher=EasyMock.createMock(RequestDispatcher.class);
  servlet=new ProcessServlet(){
   private static final long serialVersionUID = 7534303474286669635L;

   public ServletContext getServletContext(){
    return context;
   }
  };
 }
 @Test
 public void test() throws ServletException, IOException{
  EasyMock.expect(request.getParameter("username")).andReturn("abin").times(20000);
  EasyMock.expect(request.getParameter("password")).andReturn("varyall").times(20000);
  EasyMock.expectLastCall();
  EasyMock.replay(request);
  EasyMock.replay(response);
  servlet.doPost(request, response);
  EasyMock.verify(response);
  dispatcher.forward(request, response);
  StringWriter sw=new StringWriter();
  PrintWriter writer=new PrintWriter(sw, true);
  response.getOutputStream();
//  response.set
//  String line="";
//  String result="";
//  while((line=writer.)){
//   
//  }
//  BufferedReader reader=new BufferedReader(new InputStreamReader());
  
  
  
  
 }
}

本文介紹在NetBeans開發工具中編寫和運行JUnit單元測試的基礎部分。測試一個應用程序是開發周期的一部分，編寫和維護單元測試可以保證你源代碼中獨立的方法可以正常工作。

NetBeans IDE 6.9 中包含JUnit 3.5和JUnit 4.5兩個版本，可自行選擇。（關于使用JUnit的更多信息，參考www.junit.org。）

一、新建Java測試包

二、創建java類庫測試

三、JUnit注釋

1.JUnit測試注釋

2.測試類、測試的初始化函數和釋放方法

3.禁用測試注釋

四、簡單的JUnit4測試方法

五、運行測試

1. 查看processes和sessions參數

SQL> show parameter processes

NAME                                 TYPE        VALUE
------------------------------------ ----------- ------------------------------
aq_tm_processes                      integer     1
db_writer_processes                  integer     1
job_queue_processes                  integer     10
log_archive_max_processes            integer     2
processes                            integer     150

SQL> show parameter sessions

NAME                                 TYPE        VALUE
------------------------------------ ----------- ------------------------------
java_max_sessionspace_size           integer     0
java_soft_sessionspace_limit         integer     0
license_max_sessions                 integer     0
license_sessions_warning             integer     0
logmnr_max_persistent_sessions       integer     1
mts_sessions                         integer     165
sessions                             integer     170
shared_server_sessions               integer     165
SQL>

2. 修改processes和sessions值

SQL> alter system set processes=300 scope=spfile;

系統已更改。

SQL> alter system set sessions=335 scope=spfile;

系統已更改。

3. 修改processes和sessions值必須重啟oracle服務器才能生效

ORACLE的連接數(sessions)與其參數文件中的進程數(process)有關，它們的關系如下：

sessions=(1.1*process+5)

　查詢數據庫當前進程的連接數：

　select count(*) from v$process;

　　查看數據庫當前會話的連接數：

　　select count(*) from v$session;

　　查看數據庫的并發連接數：

　　select count(*) from v$session where status='ACTIVE';

　　查看當前數據庫建立的會話情況：

　　select sid,serial#,username,program,machine,status from v$session;

　查詢數據庫允許的最大連接數：

　　select value from v$parameter where name = 'processes';

　　或者：show parameter processes;

　　修改數據庫允許的最大連接數：

　　alter system set processes = 300 scope = spfile;

　　(需要重啟數據庫才能實現連接數的修改)

　　重啟數據庫：

　　shutdown immediate;

　　startup;

　　查看當前有哪些用戶正在使用數據：

　　select osuser,a.username,cpu_time/executions/1000000||'s',sql_fulltext,machine

　　from v$session a,v$sqlarea b

　　where a.sql_address = b.address

　　order by cpu_time/executions desc;

　　備注：UNIX 1個用戶session對應一個操作系統process，而Windows體現在線程。

　　啟動oracle

　　su - oracle

　　sqlplus system/pwd as sysdba   //進入sql

　　startup                                      //啟動數據庫

　　lsnrctl start                               //啟動監聽

　　sqlplus "/as sysdba"

　　shutdown immediate;

　　startup mount;

　　alter database open;

一：安裝
  1，如果是LINUX系統，可以到官方網址http://memcached.org/進行下載，安裝教程網上一大堆，這里不再敘述。
  2，如果是WINDOWS系統

     - 到http://code.jellycan.com/memcached/下載穩定版。

     - 下載后解壓到某個盤下面，比如在c:\memcached，在終端（也即cmd命令界面）下輸入 ‘c:\memcached\memcached.exe -d install’ 安裝。

     - 再輸入： ‘c:\memcached\memcached.exe -d start’ 啟動。

     - 修改memcache的內存大小，可以在注冊表里找到HKEY_LOCAL_MACHINE/SYSTEM/CurrentControlSet/Services/memcached Server，修改ImagePath的值為
“C:/memcached/memcached.exe” -d runservice -m 512
  NOTE: Windows版本一般用作開發調試只用，不建議在產品環境中使用。

二：JAVA連接使用Memcached
  1, 下載memcached客戶端開發包，地址https://github.com/gwhalin/Memcached-Java-Client
  2，下面是一個連接并使用的簡單例子

package com.ea.online.memcache;

import java.util.Date;

import com.danga.MemCached.MemCachedClient;
import com.danga.MemCached.SockIOPool;

public class MyClass {

    // create a static client as most installs only need
    // a single instance
    protected static MemCachedClient mcc = new MemCachedClient();

    protected static SockIOPool pool = null;
    // set up connection pool once at class load
    static {

        // Server list
        String[] servers = { "localhost:11211" };

        // Specify memcached capacity
        Integer[] weights = { 3, 3, 2 };

        /*
         * String[] serverlist = { "cache0.server.com:12345",
         * "cache1.server.com:12345" }; Integer[] weights = { new
         * Integer(5), new Integer(2) }; int initialConnections = 10; int
         * minSpareConnections = 5; int maxSpareConnections = 50; long
         * maxIdleTime = 1000 * 60 * 30; // 30 minutes long maxBusyTime = 1000 *
         * 60 * 5; // 5 minutes long maintThreadSleep = 1000 * 5; // 5 seconds
         * int socketTimeOut = 1000 * 3; // 3 seconds to block on reads int
         * socketConnectTO = 1000 * 3; // 3 seconds to block on initial
         * connections. If 0, then will use blocking connect (default) boolean
         * failover = false; // turn off auto-failover in event of server down
         * boolean nagleAlg = false; // turn off Nagle's algorithm on all
         * sockets in pool boolean aliveCheck = false; // disable health check
         * of socket on checkout
         *
         * SockIOPool pool = SockIOPool.getInstance();
         * pool.setServers(serverlist);
         * pool.setWeights(weights);
         * pool.setInitConn(initialConnections);
         * pool.setMinConn(minSpareConnections);
         * pool.setMaxConn(maxSpareConnections); pool.setMaxIdle(maxIdleTime);
         * pool.setMaxBusyTime(maxBusyTime);
         * pool.setMaintSleep(maintThreadSleep);
         * pool.setSocketTO(socketTimeOut); pool.setNagle(nagleAlg);
         * pool.setHashingAlg(SockIOPool.NEW_COMPAT_HASH);
         * pool.setAliveCheck(true); pool.initialize();
         */

        // grab an instance of our connection pool
        pool = SockIOPool.getInstance();

        // set the servers and the weights
        pool.setServers(servers);
        pool.setWeights(weights);

        // Specify main thread maintain frequency
        pool.setMaintSleep(30);

        // set some TCP settings
        // disable nagle
        pool.setNagle(false);
        // set the read timeout to 3 secs
        pool.setSocketTO(3000);
        // and don't set a connect timeout
        pool.setSocketConnectTO(0);

        // initialize the connection pool
        pool.initialize();

    }

    // from here on down, you can call any of the client calls
    public static void main(String[] args) {
        // Test expired
        mcc.set("foo", "This is a test String", new Date(
                new Date().getTime() + 3000));
        String bar = mcc.get("foo").toString();
        System.out.println("test-->" + bar);
        while (true) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(mcc.get("foo"));
        }
        // pool.shutDown();
    }
}

詳細使用可以借鑒這篇文章：http://sillycat.iteye.com/blog/563615

三：結合AOP編程
  1，對于memcached與spring aop的集成網上又是一堆，這里不提了。
  2，對于memcached與guice aop的集成可參考http://code.google.com/p/google-guice/wiki/AOP
  3，對于需要通過手動實現動態代理的方式來實現AOP的可以參考 http://www.aygfsteel.com/DoubleJ/archive/2008/03/04/183796.html

四：一個簡單的環繞通知切面，不可運行，僅作參考

public Around implements MethodInterceptor {
 ....
    public Object invoke(MethodInvocation mi, Object[] args) {
        Object obj = null;
        //從Memcached中獲取
        obj = mcc.get(this.class.getName() + mi.getMethodName() + args.hashcode());
        if(obj != null) {
            return obj;
        }
      
        obj = method.invoke(args);
      
        //存入Memcached
        mcc.set(this.class.getName() + mi.getMethodName() + args.hashcode, obj, expiredDate);
        return obj;
    }
 ....
} 

對于后兩種情況，用標簽遍歷時不太方便，因為無法直接轉換成實體類的對象。比較簡單的解決方法是：

　　の：hql查詢多表部分字段，select new 包名.表1實體類名(表1.屬性1，表2.屬性2……) from 表1實體類,表2實體類 where 表1.ID=表2.ID（即相關聯的字段），同時在要返回的表1實體類中添加表2的屬性和帶參的構造方法，參數的個數和順序與（表1.屬性1，表2.屬性 2……) 保持一致

例如要查詢Problem 中的pid，score，title，totalAccept,totalSubmission,unSee

 



感謝glamey兄弟的文章，正好解決了當前遇到的問題。原文鏈接如下：http://glamey.iteye.com/blog/721019
        假設我們現在有一個DTO，其屬性包括兩張表的屬性，我們現在需要將sql語句查詢得到的內容轉為一個DTO對象，其解決方法如下：  

package net.abin.lee.basic;

public class Can implements Cloneable{
 private int id;
 private String address;
 public Can() {
 }
 public Can(int id, String address) {
  super();
  this.id = id;
  this.address = address;
 }
 public Object clone()throws CloneNotSupportedException{
  return super.clone();
 }
 public int hashCode(){
  final int prime=31;
  int result=1;
  result=prime*result+id;
  result=prime*result+((address==null?0:address.hashCode()));
  return result;
 }
 public int getId() {
  return id;
 }
 public void setId(int id) {
  this.id = id;
 }
 public String getAddress() {
  return address;
 }
 public void setAddress(String address) {
  this.address = address;
 }
 
}

package net.abin.lee.basic;

import junit.framework.TestCase;

public class UserTest extends TestCase{
 public void test1() throws CloneNotSupportedException{
  User user1=new User("12","abin",3);
  User user2=user1;
  User user3=(User)user1.clone();
  System.out.println("user1=user2 :"+(user1==user2));
  System.out.println("user1equalsuser2 :"+(user1.equals(user2)));
  
  System.out.println("user1=user3 :"+(user1==user3));
  System.out.println("user1equalsuser3 :"+(user1.equals(user3)));
  
 }
 @Override
 protected void runTest() throws Throwable {
  System.out.println("55");
  super.runTest();
 }
}