java學習

  
<?xml version="1.0" encoding="UTF-8"?>

  <context-param>
    <param-name>url</param-name>
    <param-value>jdbc:oracle:thin:@localhost:1521:ORC</param-value>
  </context-param>
  <context-param>
    <param-name>username</param-name>
    <param-value>scott</param-value>
  </context-param>
  <context-param>
    <param-name>password</param-name>
    <param-value>tigger</param-value>
  </context-param>
  
  <servlet>
    <servlet-name>ConnectionServlet</servlet-name>
    <servlet-class>net.yeah.fancydeepin.servlet.ConnectionServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>ConnectionServlet</servlet-name>
    <url-pattern>/ConnectionServlet.action</url-pattern>
  </servlet-mapping>
  
  <servlet>
    <servlet-name>PrepareConnectionServlet</servlet-name>
    <servlet-class>net.yeah.fancydeepin.servlet.PrepareConnectionServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>PrepareConnectionServlet</servlet-name>
    <url-pattern>/PrepareConnectionServlet.action</url-pattern>
  </servlet-mapping>

</web-app>
  

  
package net.yeah.fancydeepin.servlet;

import java.io.IOException;
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 PrepareConnectionServlet extends HttpServlet {

    private static final long serialVersionUID = 1L;

    public void init() throws ServletException {
        
        ServletContext context = getServletContext();
        String url = context.getInitParameter("url");
        String username = context.getInitParameter("username");
        String password = context.getInitParameter("password");
        context.setAttribute("url", url);
        context.setAttribute("username", username);
        context.setAttribute("password", password);
    }

    protected void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException{
        
        doPost(request, response);
    }

    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        
        response.sendRedirect("ConnectionServlet.action");
    }
}

  

  
package net.yeah.fancydeepin.servlet;

import java.io.IOException;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServlet;

public class ConnectionServlet extends HttpServlet {

    private static final long serialVersionUID = 1L;

    public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {
        
        ServletContext context = getServletContext();
        System.out.println("***************************************");
        System.out.println("URL: " + context.getAttribute("url"));
        System.out.println("Username: " + context.getAttribute("username"));
        System.out.println("Password: " + context.getAttribute("password"));
        System.out.println("***************************************");
        super.service(request, response);
    }
}
  

  
***********************************************
URL:  jdbc:oracle:thin:@localhost:1521:ORC
Username:  scott
Password:  tigger
***********************************************
  

  
public ActionForward execute(ActionMapping mapping,ActionForm form,HttpServletRequest request,HttpServletResponse response){
    // TODO Auto-generated method stub
    return null;
}
  

  
package net.yeah.fancydeepin.action;

import java.util.Map;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
import com.opensymphony.xwork2.util.ValueStack;

public class ContextAction extends ActionSupport {

    private static final long serialVersionUID = 1L;
    private String username;
    private String password;

    public String execute(){
        
        ActionContext context = ActionContext.getContext();
        ValueStack value = context.getValueStack();
        value.set("username", username);
        value.set("password", password);
        Map<String, Object> session = context.getSession();
        session.put("url", "http://www.aygfsteel.com/fancydeepin");
        return SUCCESS;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}

  

  
<s:property value="username"/><BR>
<s:property value="password"/><BR>
<s:property value="#session.url"/><BR>
  

  
public String execute(){
        
    //或 implements ServletRequestAware
    HttpServletRequest request = ServletActionContext.getRequest();
    //或 implements ServletResponseAware
    HttpServletResponse response = ServletActionContext.getResponse();
    //或 implements SessionAware
    HttpSession session = request.getSession();
    //或 implements ServletContextAware
    ServletContext context = ServletActionContext.getServletContext();
        
    return SUCCESS;
}
  

public static int method(int n){

if(n==1){

return 1;

}else {

return n*method(n-1);

}

}

DATE_FORMAT() 函數用于以不同的格式顯示日期/時間數據。

DATE_FORMAT(date,format)

date 參數是合法的日期。format 規定日期/時間的輸出格式。

下面的腳本使用 DATE_FORMAT() 函數來顯示不同的格式。我們使用 NOW() 來獲得當前的日期/時間：

DATE_FORMAT(NOW(),'%b %d %Y %h:%i %p') DATE_FORMAT(NOW(),'%m-%d-%Y') DATE_FORMAT(NOW(),'%d %b %y') DATE_FORMAT(NOW(),'%d %b %Y %T:%f')

結果類似：

Dec 29 2008 11:45 PM 12-29-2008 29 Dec 08 29 Dec 2008 16:25:46.635

2013-03-25 14:35:20

DATE_FORMAT(timetext,'%Y')=‘2013’
按年排序按月查詢

package com.test;


/**
 * 動態生成隨機字符數組
 *  
 *
 */
public class ShortMessageCodeUntil
{


    /**
     * 隨機生成4位數字字符數組
     *  
     * @return rands
     */
    public static char[] generateCheckCode()
    {
        String chars = "0123456789";
        char[] rands = new char[4];
        for (int i = 0; i < 4; i++)
        {
            int rand = (int) (Math.random() * 10);
            rands[i] = chars.charAt(rand);
        }
        return rands;
    }


    /**
     * 隨機生成6位數字字符數組
     *  
     * @return rands
     */
    public static char[] generateCheckPass()
    {
        String chars = "0123456789";
        char[] rands = new char[6];
        for (int i = 0; i < 6; i++)
        {
            int rand = (int) (Math.random() * 10);
            rands[i] = chars.charAt(rand);
        }
        return rands;
    }
public static void main(String[] args) {
    ShortMessageCodeUntil sm = new ShortMessageCodeUntil();
    System.out.println(sm.generateCheckCode());
    System.out.println(sm.generateCheckPass());
}

}

<div><a href="javascript:void(0)" class="aa" rel="<%=k %>">點擊</a></div>

 <script type="text/javascript">
        $(document).ready(function(){
            $(".aa").click(function(){        
            
                    var id = $(this).attr("rel");
                    $.get('<%=basePath%>wenshi/setDaPeng', {
            p :id
        }, function(r,s) {
      
    
        });
                    
                    
            
                
            });
        });
    </script>

Builder模式定義: 將一個復雜對象的構建與它的表示分離,使得同樣的構建過程可以創建不同的表示.
Builder模式是一步一步創建一個復雜的對象,它允許用戶可以只通過指定復雜對象的類型和內容就可以構建它們.
用戶不知道內部的具體構建細節.Builder模式是非常類似抽象工廠模式,細微的區別大概只有在反復使用中才能體會到.
為何使用? 是為了將構建復雜對象的過程和它的部件解耦.注意: 是解耦過程和部件.
因為一個復雜的對象,不但有很多大量組成部分,如汽車,有很多部件:車輪方向盤 發動機還有各種小零件等等,
部件很多,但遠不止這些,如何將這些部件裝配成一輛汽車,這個裝配過程也很復雜(需要很好的組裝技術),Builder模式就是為了將部件和組裝過程分開.
如何使用? 首先假設一個復雜對象是由多個部件組成的,Builder模式是把復雜對象的創建和部件的創建分別開來,分別用Builder類和Director類來表示.
首先,需要一個接口,它定義如何創建復雜對象的各個部件:
public interface Builder {
//創建部件A 比如創建汽車車輪
 void buildPartA();
 //創建部件B 比如創建汽車方向盤
 void buildPartB();
 //創建部件C 比如創建汽車發動機
 void buildPartC();
 //返回最后組裝成品結果 (返回最后裝配好的汽車)
 //成品的組裝過程不在這里進行,而是轉移到下面的Director類中進行. //從而實現了解耦過程和部件
 Product getResult();
}
 用Director構建最后的復雜對象,而在上面Builder接口中封裝的是如何創建一個個部件(復雜對象是由這些部件組成的),也就是說Director的內容是如何將部件最后組裝成成品:
 public class Director {
private Builder builder;
public Director( Builder builder ) {
 this.builder = builder;
 } // 將部件partA partB partC最后組成復雜對象 //這里是將車輪方向盤和發動機組裝成汽車的過程
 public void construct() {
 builder.buildPartA();
 builder.buildPartB();
 builder.buildPartC();
}
}
Builder的具體實現ConcreteBuilder: 通過具體完成接口Builder來構建或裝配產品的部件;
定義并明確它所要創建的是什么具體東西; 提供一個可以重新獲取產品的接口:
public class ConcreteBuilder implements Builder {
Part partA, partB, partC; public void buildPartA() {
//這里是具體如何構建partA的代碼 };
public void buildPartB() {
 //這里是具體如何構建partB的代碼 };
 public void buildPartC() {
 //這里是具體如何構建partB的代碼 };
 public Product getResult() { //返回最后組裝成品結果 };
 復雜對象:產品Product:
public interface Product { }
復雜對象的部件:
public interface Part { }
我們看看如何調用Builder模式:
ConcreteBuilder builder = new ConcreteBuilder();
 Director director = new Director( builder );
 director.construct();
 Product product = builder.getResult();
 
}

Builder模式的應用在Java實際使用中,我們經常用到"池"(Pool)的概念,當資源提供者無法提供足夠的資源,并且這些資源需要被很多用戶反復共享時,就需要使用池.
"池"實際是一段內存,當池中有一些復雜的資源的"斷肢"(比如數據庫的連接池,也許有時一個連接會中斷),如果循環再利用這些"斷肢",將提高內存使用效率,提高池的性能.修改Builder模式中Director類使之能診斷"斷肢"斷在哪個部件上,再修復這個部件.

單態定義: Singleton模式主要作用是保證在Java應用程序中，一個類Class只有一個實例存在。
在很多操作中，比如建立目錄 數據庫連接都需要這樣的單線程操作。
還有, singleton能夠被狀態化; 這樣，多個單態類在一起就可以作為一個狀態倉庫一樣向外提供服務，比如，你要論壇中的帖子計數器，每次瀏覽一次需要計數，單態類能否保持住這個計數，并且能synchronize的安全自動加1，如果你要把這個數字永久保存到數據庫，你可以在不修改單態接口的情況下方便的做到。
另外方面，Singleton也能夠被無狀態化。提供工具性質的功能， Singleton模式就為我們提供了這樣實現的可能。使用Singleton的好處還在于可以節省內存，因為它限制了實例的個數，有利于Java垃圾回收（garbage collection）。我們常?？吹焦S模式中類裝入器(class loader)中也用Singleton模式實現的,因為被裝入的類實際也屬于資源。
public class Singleton {
private Singleton(){}
//在自己內部定義自己一個實例，是不是很奇怪？ //注意這是private 只供內部調用
private static Singleton instance = new Singleton();
//這里提供了一個供外部訪問本class的靜態方法，可以直接訪問
public static Singleton getInstance() {
 return instance;
 }
 }
第二種形式:
public class Singleton {
private Singleton(){}
private static Singleton instance = null;
 public static synchronized Singleton getInstance() {
 //這個方法比上面有所改進，不用每次都進行生成對象，只是第一次 //使用時生成實例，提高了效率！
 if (instance==null)
 instance＝new Singleton();
 return instance;
 }
}
使用Singleton.getInstance()可以訪問單態類。
上面第二中形式是lazy initialization，也就是說第一次調用時初始Singleton，以后就不用再生成了。
注意到lazy initialization形式中的synchronized，這個synchronized很重要，如果沒有synchronized，那么使用getInstance()是有可能得到多個Singleton
實例。
一般認為第一種形式要更加安全些。

工廠模式定義:提供創建對象的接口
為什么工廠模式是如此常用？因為工廠模式就相當于創建實例對象的new，我們經常要根據類Class生成實例對象，如A a=new A() 工廠模式也是用來創建實例對象的，所以以后new時就要多個心眼，是否可以考慮實用工廠模式，雖然這樣做，可能多做一些工作，但會給你系統帶來更大的可擴展性和盡量少的修改量。
我們以類Sample為例， 如果我們要創建Sample的實例對象:
Sample sample=new Sample();
可是，實際情況是，通常我們都要在創建sample實例時做點初始化的工作,比如賦值查詢數據庫等。
首先，我們想到的是，可以使用Sample的構造函數，這樣生成實例就寫成:
Sample sample=new Sample(參數);
但是，如果創建sample實例時所做的初始化工作不是象賦值這樣簡單的事，可能是很長一段代碼，如果也寫入構造函數中，那你的代碼很難看了（就需要Refactor重整）。
為什么說代碼很難看，初學者可能沒有這種感覺，我們分析如下，初始化工作如果是很長一段代碼，說明要做的工作很多，將很多工作裝入一個方法中，相當于將很多雞蛋放在一個籃子里，是很危險的，這也是有背于Java面向對象的原則，面向對象的封裝(Encapsulation)
和分派(Delegation)告訴我們，盡量將長的代碼分派“切割”成每段，將每段再“封裝”起來(減少段和段之間偶合聯系性)，這樣，就會將風險分散，以后如果需要修改，只要更改每段，不會再發生牽一動百的事情。
在本例中，首先，我們需要將創建實例的工作與使用實例的工作分開, 也就是說，讓創建實例所需要的大量初始化工作從Sample的構造函數中分離出去。
這時我們就需要Factory工廠模式來生成對象了，不能再用上面簡單new Sample(參數)。還有,如果Sample有個繼承如MySample, 按照面向接口編程,我們需要將Sample抽象成一個接口.現在Sample是接口,有兩個子類MySample 和HisSample .我們要實例化他們時,如下:
Sample mysample=new MySample(); Sample hissample=new HisSample();
隨著項目的深入,Sample可能還會"生出很多兒子出來", 那么我們要對這些兒子一個個實例化,更糟糕的是,可能還要對以前的代碼進行修改:加入后來生出兒子的實例.這在傳統程序中是無法避免的.
但如果你一開始就有意識使用了工廠模式,這些麻煩就沒有了.
工廠方法你會建立一個專門生產Sample實例的工廠:
public class Factory{
public static Sample creator(int which){
//getClass 產生Sample 一般可使用動態類裝載裝入類。 if (which==1) return new SampleA(); else if (which==2)
return new SampleB();
}
}
那么在你的程序中,如果要實例化Sample時.就使用
Sample sampleA=Factory.creator(1);
這樣,在整個就不涉及到Sample的具體子類,達到封裝效果,也就減少錯誤修改的機會
使用工廠方法要注意幾個角色，首先你要定義產品接口，如上面的Sample,產品接口下有Sample接口的實現類,如SampleA,其次要有一個factory類，用來生成產品Sample，
進一步稍微復雜一點，就是在工廠類上進行拓展，工廠類也有繼承它的實現類concreteFactory了。
抽象工廠 工廠模式中有: 工廠方法(Factory Method) 抽象工廠(Abstract Factory).
這兩個模式區別在于需要創建對象的復雜程度上。如果我們創建對象的方法變得復雜了,如上面工廠方法中是創建一個對象Sample,如果我們還有新的產品接口Sample2.
這里假設：Sample有兩個concrete類SampleA和SamleB，而Sample2也有兩個concrete類Sample2A和SampleB2
那么，我們就將上例中Factory變成抽象類,將共同部分封裝在抽象類中,不同部分使用子類實現，下面就是將上例中的Factory拓展成抽象工廠:
public abstract class Factory{
public abstract Sample creator();
public abstract Sample2 creator(String name);
}
public class SimpleFactory extends Factory{
public Sample creator(){ ......... return new SampleA }
public Sample2 creator(String name){ ......... return new Sample2A }
}
public class BombFactory extends Factory{
public Sample creator(){ ...... return new SampleB }
public Sample2 creator(String name){ ...... return new Sample2B }
}
從上面看到兩個工廠各自生產出一套Sample和Sample2,也許你會疑問，為什么我不可以使用兩個工廠方法來分別生產Sample和Sample2?
抽象工廠還有另外一個關鍵要點，是因為 SimpleFactory內，生產Sample和生產Sample2的方法之間有一定聯系，所以才要將這兩個方法捆綁在一個類中，這個工廠類有其本身特征，也許制造過程是統一的，比如：制造工藝比較簡單，所以名稱叫SimpleFactory。