精品婷婷色一区二区三区蜜桃,67194成人在线观看,日本福利片高清在线观看

(轉貼)數據庫連接(內連接，外連接，交叉連接)

數據庫連接分為：內連接，外連接(左、右連接，全連接)，交叉連接
文章地址： http://www.zxbc.cn/html/20080527/51189.html

轉載

內連接：把兩個表中數據對應的數據查出來

外連接：以某個表為基礎把對應數據查出來（全連接是以多個表為基礎）

student表

no name

1 a

2 b

3 c

4 d

grade表

no grade

1 90

2 98

3 95

內連接 inner join（查找條件中對應的數據，no4沒有數據不列出來）

語法：select * from student inner join grade on student.no = grade.no

結果

student.no name grade.no grade

1 a 1 90

2 b 2 98

3 c 3 95

左連接（左表中所有數據，右表中對應數據）

語法：select * from student left join grade on student.no = grade.no

結果：

student.no name grade.no grade

1 a 1 90

2 b 2 98

3 c 3 95

4 d

右連接（右表中所有數據，左表中對應數據）

語法：select * from student right join grade on student.no = grade.no

結果：

student.no name grade.no grade

1 a 1 90

2 b 2 98

3 c 3 95

全連接

語法：select * from student full join grade on student.no = grade.no

結果：

no name grade

1 a 90

2 b 98

3 c 95

4 d

1 a 90

2 b 98

3 c 95

注：access 中不能直接使用full join ，需要使用union all 將左連接和右連接合并后才可以

交叉連接
將兩個表所有行組合，連接后的行數為兩個表行數的乘積（笛卡爾積）
語法，借用上面的例子應該是

select * from student cross join grade

行數應該為12行：

no name grade

1 a 90

2 b 98

3 c 95

4 d

1 a 90

2 b 98

3 c 95

4 d

1 a 90

2 b 98

3 c 95

4 d

posted @ 2011-11-30 17:24 AK47 閱讀(495) | 評論 (0) | 編輯收藏

JAXB向Xml非根節點添加一個或多個屬性

JAXB 向Xml非根節點添加一個或多個屬性，直接上代碼，關于JAXB的相關注解可查閱JAVA API。

原創文章，轉載請注明出處。http://www.aygfsteel.com/kangdy/archive/2011/11/23/364635.html

code1: colors類根節點

code1

package com.kangdy.test;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "Colors")
@XmlAccessorType(XmlAccessType.FIELD)
public class Colors {

   @XmlElement(name = "red",nillable=true)
   private Red red;

   @XmlElement(name = "blue",nillable=true)
   private Blue blue;

   public Red getRed() {
       return red;
   }

   public Blue getBlue() {
       return blue;
   }

   public void setRed(Red red) {
       this.red = red;
   }

   public void setBlue(Blue blue) {
       this.blue = blue;
   }
}

code2: Red類子節點

code2package com.kangdy.test;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "red")
@XmlAccessorType(XmlAccessType.FIELD)
public class Red {

   private String value;

   @XmlAttribute(name = "att1")
   private String att;

   public String getValue() {
       return value;
   }

   public void setValue(String value) {
       this.value = value;
   }

   public String getAtt() {
       return att;
   }

   public void setAtt(String att) {
       this.att = att;
   }

}

code3: 類 Blue 子節點

code3

package com.kangdy.test;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "blue")
@XmlAccessorType(XmlAccessType.FIELD)
public class Blue {
   private String value;

   @XmlAttribute(name = "att2")
   private String att2;

   @XmlAttribute(name = "att1")
   private String att;

   public String getAtt() {
       return att;
   }

   public void setAtt(String att) {
       this.att = att;
   }

   public String getValue() {
       return value;
   }

   public void setValue(String value) {
       this.value = value;
   }

   public String getAtt2() {
       return att2;
   }

   public void setAtt2(String att2) {
       this.att2 = att2;
   }
}

code4: main類

code4

package com.kangdy.test;

import java.io.StringWriter;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.Marshaller;

public class Jaxbtest {
   public static void main(String[] args) throws Exception {

       StringWriter writer = new StringWriter();
       JAXBContext jc = JAXBContext.newInstance(Colors.class);
       Marshaller ma = jc.createMarshaller();
       ma.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);

       Colors colors = new Colors();
       Red red = new Red();
       red.setAtt("att-red");
       red.setValue("red");
       Blue blue = new Blue();
       blue.setValue("blue");
       blue.setAtt("att-blue");
       blue.setAtt2("blue-att2");
       colors.setRed(red);
       colors.setBlue(blue);

       ma.marshal(colors, writer);
       System.out.println(writer.toString());

   }
}

運行結果：

結果

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Colors>
    <red att1="att-red">
        <value>red</value>
    </red>
    <blue att1="att-blue" att2="blue-att2">
        <value>blue</value>
    </blue>
</Colors>

posted @ 2011-11-23 14:33 AK47 閱讀(10142) | 評論 (4) | 編輯收藏

(轉載)關于paramsPrepareParamsStack

原帖地址：

http://hi.baidu.com/%CC%AB%C6%BD%D1%F31986/blog/item/110b13b1384e805e08230259.html

轉貼

paramsPrepareParamsStack在Struts 2.0中是一個很奇妙的interceptor stack，以至于很多人疑問為何不將其設置為默認的interceptor stack。paramsPrepareParamsStack主要解決了ModelDriven和Preparable的配合問題，從字面上理解來說，這個stack的攔截器調用的順序為：首先params，然后prepare，接下來modelDriven，最后再params。Struts 2.0的設計上要求modelDriven在params之前調用，而業務中prepare要負責準備model，準備model又需要參數，這就需要在 prepare之前運行params攔截器設置相關參數，這個也就是創建paramsPrepareParamsStack的原因。流程如下：
   1. params攔截器首先給action中的相關參數賦值，如id
   2. prepare攔截器執行prepare方法，prepare方法中會根據參數，如id，去調用業務邏輯，設置model對象
   3. modelDriven攔截器將model對象壓入value stack，這里的model對象就是在prepare中創建的
   4. params攔截器再將參數賦值給model對象
   5. action的業務邏輯執行依據此stack，一個action的代碼通常如下：

public class UserAction extends ActionSupport implements ModelDriven, Preparable {
   private User user;
   private int id;
   private UserService service; // user business service

   public void setId(int id) {
       this.id = id;
   }

   /**
   * create a new user if none exists, otherwise load the user with the
   * specified id
   */
   public void prepare() throws Exception {
       if (id == 0) {
           user = new User();
       } else {
           user = service.findUserById(id);
       }
   }

   public Object getModel() {
       return user;
   }

   /**
   * create or update the user and then view the created user
   */
   public String update() {
       if (id == 0) {
           service.create(user);
       } else {
           service.update(user);
       }
       return "redirect";
   }

   /**
   * delete the user and go to a default home page
   */
   public String delete() {
       service.deleteById(id);
       return "home";
   }

   /**
   * show the page allowing the user to view the existing data
   */
   public String view() {
       return "view";
   }

   /**
   * show the page allowing the user to view the existing data and change the
   * values
   */
   public String edit() {
       return "input";
   }

在上述代碼中，edit和view都不需要根據id再為界面準備數據，因為prepare方法已經準備好了model，這些方法很簡單。對于update 方法，prepare首先會從數據庫中加載數據，然后params攔截器會將參數值付給model，在update直接更新就可以，不會出現數據被亂更新的情況。象Hibernate框架，會判斷哪些字段更新了，然后進行更新，性能也不會損失。
通過paramsPrepareParamsStack可以讓流程更明確，代碼更簡潔，也更利于大家的交流。

posted @ 2011-11-16 15:39 AK47 閱讀(444) | 評論 (0) | 編輯收藏

(轉載) Struts 2雜談（1）：ValueStack對象的傳送帶機制

Struts 2雜談（1）：ValueStack對象的傳送帶機制

作者：nokiaguy 原文地址：http://blog.csdn.net/nokiaguy/article/details/4684750

轉貼

   眾所周知，Strut 2的Action類通過屬性可以獲得所有相關的值，如請求參數、Action配置參數、向其他Action傳遞屬性值（通過chain結果）等等。要獲得這些參數值，我們要做的唯一一件事就是在Action類中聲明與參數同名的屬性，在Struts 2調用Action類的Action方法（默認是execute方法）之前，就會為相應的Action屬性賦值。
    要完成這個功能，有很大程度上，Struts 2要依賴于ValueStack對象。這個對象貫穿整個Action的生命周期（每個Action類的對象實例會擁有一個ValueStack對象）。當 Struts 2接收到一個.action的請求后，會先建立Action類的對象實例，并且將Action類的對象實例壓入ValueStack對象中（實際上，ValueStack對于相當一個棧），而ValueStack類的setValue和findValue方法可以設置和獲得Action對象的屬性值。Struts 2中的某些攔截器正是通過ValueStack類的setValue方法來修改Action類的屬性值的。如params攔截器用于將請求參數值映射到相應成Action類的屬性值。在params攔截器中在獲得請求參數值后，會使用setValue方法設置相應的Action類的屬性。
    從這一點可以看出，ValueStack對象就象一個傳送帶，當客戶端請求.action時，Struts 2在創建相應用Action對象后就將Action對象放到了ValueStack傳送帶上，然后ValueStack傳送帶會帶著Action對象經過若干攔截器，在每一攔截器中都可以通過ValueStack對象設置和獲得Action對象中的屬性值。實際上，這些攔截器就相當于流水線作業。如果要對 Action對象進行某項加工，再加一個攔截器即可，當不需要進行這項工作時，直接將該攔截器去掉即可。
    下面我們使用一個例子來演示這個過程。在這個例子中實現了一個攔截器，該攔截器的功能是將一個屬性文件中的key-value對映射成相應的屬性的值。如下面是一個屬性文件的內容：

    name = 超人
    price = 10000

    我們可以在Action類中定義name和price屬性，在Action中引用這個攔截器后，就會自動為屬性賦值。
    在使用該攔截器有如下規則：
    1. 攔截器讀取的屬性文件路徑由path參數指定。
    2. 屬性文件的編碼格式由encoding參數指定，默認值是UTF-8。
    3. 如果某個key中包含有“.”（該符號不能出現在標識符中），則有如下處理方法：
    （1）將Action類的屬性名定義為去掉“.”的key。例如，key為person.name，而屬性名可定義為personname。
    （2）將Action類的屬性名定義為將“.”替換成其他字符的表示符號。例如，key為person.name，而屬性名可定義為person_name，其中“_”由separator參數指定。
    4. 如果key太長，也可以直接使用Action參數進行映射，例如，key為country.person.name，可做如下映射：
      <param name="countrypersonname">name</param>
      要注意的是，name屬性值不能包含“.”，因此，應將key值中的“.”去掉。現在就可以直接在Action類中定義名為name的屬性的，name屬性的值會與key值相同。
    5. 上面所有的規則可以同時使用。

攔截器的源代碼：

package interceptors;

import java.util.Enumeration;
import java.util.Map;
import java.util.Properties;
import java.io.InputStream;
import java.io.FileInputStream;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionInvocation;
import com.opensymphony.xwork2.config.entities.ActionConfig;
import com.opensymphony.xwork2.interceptor.AbstractInterceptor;
import com.opensymphony.xwork2.util.ValueStack;

public class PropertyInterceptor extends AbstractInterceptor
{
    private static final String DEFAULT_PATH_KEY = "path";
    private static final String DEFAULT_ENCODING_KEY = "encoding";
    private static final String DEFAULT_SEPARATOR_KEY = "separator";

    protected String pathKey = DEFAULT_PATH_KEY;
    protected String encodingKey = DEFAULT_ENCODING_KEY;
    protected String separatorKey = DEFAULT_SEPARATOR_KEY;

    public void setPathKey(String pathKey)
    {
        this.pathKey = pathKey;
    }

    public void setEncodingKey(String encodingKey)
    {
        this.encodingKey = encodingKey;
    }

    public void setSeparatorKey(String separatorKey)
    {
        this.separatorKey = separatorKey;
    }

    @Override
    public String intercept(ActionInvocation invocation) throws Exception
    {
        ActionConfig config = invocation.getProxy().getConfig();

        Map<String, String> parameters = config.getParams();
        if (parameters.containsKey(pathKey))
        {
            String path = parameters.get(pathKey);
            String encoding = parameters.get(encodingKey);
            String separator = parameters.get(separatorKey);
            if (encoding == null)
                encoding = "UTF-8";
            if (separator == null)
                separator = "";
            path = invocation.getAction().getClass().getResource(path)
                    .getPath();
            Properties properties = new Properties();
            InputStream is = new FileInputStream(path);
            java.io.Reader reader = new java.io.InputStreamReader(is, encoding);

            properties.load(reader);
            ActionContext ac = invocation.getInvocationContext();
            ValueStack stack = ac.getValueStack();
            System.out.println(stack.hashCode());
            Enumeration names = properties.propertyNames();
            while (names.hasMoreElements())
            {
                //  下面會使用setValue方法修改ValueStack對象中的相應屬性值
                String name = names.nextElement().toString();
                if (!name.contains("."))
                    stack.setValue(name, properties.get(name));

                String newName = null;
                newName = parameters.get(name.replaceAll("//.", ""));
                if (newName != null)
                    stack.setValue(newName, properties.get(name));

                if (!separator.equals(""))
                {
                    newName = name.replaceAll("//.", "");
                    stack.setValue(newName, properties.get(name));
                }
                newName = name.replaceAll("//.", separator);
                stack.setValue(newName, properties.get(name));
            }
        }
        return invocation.invoke();
    }
}

用于測試的Action類的源代碼：

package actions;

public class MyAction
{
    private String name;
    private Integer price;
    private String log4jappenderstdout;
    private String log4j_rootLogger;
    private String conversionPattern;

    public String getName()
    {
        return name;
    }

    public void setName(String name)
    {
        this.name = name;
    }

    public Integer getPrice()
    {
        return price;
    }

    public void setPrice(Integer price)
    {
        this.price = price;
    }

    public String getLog4jappenderstdout()
    {
        return log4jappenderstdout;
    }

    public void setLog4jappenderstdout(String log4jappenderstdout)
    {
        this.log4jappenderstdout = log4jappenderstdout;
    }

    public String getLog4j_rootLogger()
    {
        return log4j_rootLogger;
    }

    public void setLog4j_rootLogger(String log4j_rootLogger)
    {
        this.log4j_rootLogger = log4j_rootLogger;
    }

    public String getConversionPattern()
    {
        return conversionPattern;
    }

    public void setConversionPattern(String conversionPattern)
    {
        this.conversionPattern = conversionPattern;
    }

    public String execute()
    {
        System.out.println("name:" + name);
        System.out.println("price:" + price);
        System.out.println("log4jappenderstdout:" + log4jappenderstdout);
        System.out.println("log4j_rootLogger:" + log4j_rootLogger);
        System.out.println("conversionPattern:" + conversionPattern);
        return null;
    }
}

Action類的配置代碼如：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE struts PUBLIC
    "-//Apache Software Foundation//DTD Struts Configuration 2.1//EN"
    "http://struts.apache.org/dtds/struts-2.1.dtd">
<struts>
    <package name="struts" extends="struts-default">

        <interceptors>
            <interceptor name="property"
                class="interceptors.PropertyInterceptor" />
            <interceptor-stack name="myStack">
                <interceptor-ref name="defaultStack" />
                <interceptor-ref name="property" />
            </interceptor-stack>
        </interceptors>
        <action name="test" class="actions.MyAction">
            <interceptor-ref name="myStack" />
            <param name="path">/log4j.properties</param>
            <param name="encoding">UTF-8</param>
            <param name="separator">_</param>
            <param name="log4jappenderstdoutlayoutConversionPattern">
                conversionPattern
            </param>

        </action>
    </package>
</struts>

請將log4j.properties文件復制到WEB-INF/classes目錄，并在該文件中加入name和price屬性。

測試結果：

name:中國
price:34
log4jappenderstdout:org.apache.log4j.ConsoleAppender
log4j_rootLogger:error, stdout
conversionPattern:%d{ABSOLUTE} %5p %c{1}:%L - %m%n

由于property攔截器在defaultStack后引用，因此，在該攔截器中設置的屬性值是最終結果，如果將property攔截器放在 defaultStack前面（將兩個<interceptor-ref>元素掉換一下），就可以通過同名勝Action配置參數或請求參數來干預最終究輸出結果了。

posted @ 2011-11-11 17:21 AK47 閱讀(376) | 評論 (0) | 編輯收藏

(轉貼)Struts2數據傳輸的背后機制：ValueStack（值棧）

摘要: （轉）Struts2數據傳輸的背后機制：ValueStack（值棧）原文地址：http://blog.csdn.net/li_tengfei/article/details/6098134轉載 1. 數據傳輸背后機制：ValueStack(值棧) 在這一切的背后，是因為有了ValueStack（值棧）！ Valu... 閱讀全文

posted @ 2011-11-11 16:19 AK47 閱讀(820) | 評論 (0) | 編輯收藏

structs2配置UrlRewriteFilter

轉載每個網頁或請求都是一個url地址，一般，這個地址可能是.do,.page,.action之類的并加上'?'號、'&'號查詢串等構成的一個長長的的url。很urgly。

一般的url----------------------------------------------------------較好的url
http://www.xxx.net/user/profile.do?id=20001   ====> http://www.xxx.net/user/20001
http://www.xxx.net/forum/board.do?name=java   ====> http://www.xxx.net/forum/java
http://www.xxx.net/forum/thread.do?id=29923   ====> http://www.xxx.net/thread/29923

后者明顯較為直觀和漂亮。

使用url rewrite可以很好的改善這個狀況。網站url rewrite應用是非常廣泛的，良好的url設計給用戶帶來的非常好的體驗，同時也能吸引搜索引擎的注意。

原文地址：http://www.iteye.com/topic/53834
使用方式：
1 配置web.xml文件
樣例：

    <listener>
       <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
   </listener>
   <filter>
       <filter-name>encodingFilter</filter-name>
       <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
       <init-param>
           <param-name>encoding</param-name>
           <param-value>UTF-8</param-value>
       </init-param>
   </filter>
   <filter-mapping>
       <filter-name>encodingFilter</filter-name>
       <url-pattern>/*</url-pattern>
   </filter-mapping>
   <filter>
       <filter-name>osivFilter</filter-name>
       <filter-class>
           org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
   </filter>
   <listener>
       <listener-class>
           org.springframework.web.context.request.RequestContextListener</listener-class>
   </listener>
   <filter-mapping>
       <filter-name>osivFilter</filter-name>
       <url-pattern>/*</url-pattern>
   </filter-mapping>

<filter>
       <filter-name>UrlRewriteFilter</filter-name>
       <filter-class>org.tuckey.web.filters.urlrewrite.UrlRewriteFilter</filter-class>
   </filter>
   <filter-mapping>
       <filter-name>UrlRewriteFilter</filter-name>
       <url-pattern>*.html</url-pattern>
       <dispatcher>REQUEST</dispatcher>
       <dispatcher>FORWARD</dispatcher>
       <dispatcher>INCLUDE</dispatcher>
   </filter-mapping>
   <filter>
       <filter-name>struts-prepare</filter-name>
       <filter-class>
           org.apache.struts2.dispatcher.ng.filter.StrutsPrepareFilter</filter-class>
       <init-param>
           <param-name>actionPackages</param-name>
           <param-value>com.secneo.action.*.*</param-value>
       </init-param>
   </filter>
   <filter>
       <filter-name>struts2</filter-name>
       <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
   </filter>

   <filter>
       <filter-name>struts-execute</filter-name>
       <filter-class>
           org.apache.struts2.dispatcher.ng.filter.StrutsExecuteFilter</filter-class>
   </filter>
   <filter>
       <filter-name>struts-cleanup</filter-name>
       <filter-class>org.apache.struts2.dispatcher.ActionContextCleanUp</filter-class>
   </filter>
   <filter-mapping>
       <filter-name>struts2</filter-name>
       <url-pattern>*.jsp</url-pattern>
   </filter-mapping>
    
    <filter-mapping>
       <filter-name>struts2</filter-name>
       <url-pattern>*.action</url-pattern>
       <dispatcher>REQUEST</dispatcher>
       <dispatcher>FORWARD</dispatcher>
       <dispatcher>INCLUDE</dispatcher>
   </filter-mapping>
   <filter-mapping>
       <filter-name>struts2</filter-name>
       <url-pattern>*.tld</url-pattern>
   </filter-mapping>
   <filter-mapping>
       <filter-name>struts2</filter-name>
       <url-pattern>*.tag</url-pattern>
   </filter-mapping>

   <filter-mapping>
       <filter-name>struts-prepare</filter-name>
       <url-pattern>*.jsp</url-pattern>
   </filter-mapping>
   <filter-mapping>
       <filter-name>struts-prepare</filter-name>
       <url-pattern>*.action</url-pattern>
   </filter-mapping>
   <filter-mapping>
       <filter-name>struts-prepare</filter-name>
       <url-pattern>*.tld</url-pattern>
   </filter-mapping>

   <filter-mapping>
       <filter-name>struts-execute</filter-name>
       <url-pattern>*.jsp</url-pattern>
   </filter-mapping>
   <filter-mapping>
       <filter-name>struts-execute</filter-name>
       <url-pattern>*.action</url-pattern>
   </filter-mapping>
   <filter-mapping>
       <filter-name>struts-execute</filter-name>
       <url-pattern>*.tld</url-pattern>
   </filter-mapping>

   <filter-mapping>
       <filter-name>struts-cleanup</filter-name>
       <url-pattern>*.jsp</url-pattern>
   </filter-mapping>
   <filter-mapping>
       <filter-name>struts-cleanup</filter-name>
       <url-pattern>*.action</url-pattern>
   </filter-mapping>
   <filter-mapping>
       <filter-name>struts-cleanup</filter-name>
       <url-pattern>*.tld</url-pattern>
   </filter-mapping>
   <listener>
       <listener-class>
           org.springframework.web.util.IntrospectorCleanupListener</listener-class>
   </listener>

2 在WEB-INF目錄下添加urlrewrite.xml 文件，根據具體需要寫規則。
樣例：

<?xml version="1.0" encoding="utf-8"?>
<urlrewrite>
   <rule>
       <from>^/(.*).html$</from>
       <to type="forward">/$1.action</to>
   </rule>
   <rule>
       <from>^/(.*).html?(.*)$</from>
       <to type="forward">/$1.action?$2</to>
   </rule>
</urlrewrite>

posted @ 2011-11-09 17:22 AK47 閱讀(1783) | 評論 (0) | 編輯收藏

structs2 filter的執行順序

根據servlet2.3規范filter執行是按照web.xml配置的filter-mapping先后順序進行執行。
所以自己配置的過濾器放在structs2的過濾器之前。

posted @ 2011-11-09 15:44 AK47 閱讀(380) | 評論 (0) | 編輯收藏

(轉貼)數據庫連接(內連接，外連接，交叉連接)

JAXB向Xml非根節點添加一個或多個屬性

(轉載)關于paramsPrepareParamsStack

(轉載) Struts 2雜談（1）：ValueStack對象的傳送帶機制

(轉貼)Struts2數據傳輸的背后機制：ValueStack（值棧）

structs2配置UrlRewriteFilter

structs2 filter的執行順序

導航

統計

常用鏈接

留言簿

隨筆分類

隨筆檔案

搜索

最新評論

閱讀排行榜

評論排行榜