public class CustomRequestProcessor
        extends RequestProcessor {
    protected boolean processPreprocess (
            HttpServletRequest request,
            HttpServletResponse response) {
        HttpSession session = request.getSession(false);
        //If user is trying to access login page
        // then don't check
        if( request.getServletPath().equals("/loginInput.do")
            || request.getServletPath().equals("/login.do") )
            return true;
        //Check if userName attribute is there is session.
        //If so, it means user has allready logged in
        if( session != null &&
        session.getAttribute("userName") != null)
            return true;
        else{
            try{
                //If no redirect user to login Page
                request.getRequestDispatcher 
                    ("/Login.jsp").forward(request,response);
            }catch(Exception ex){
            }
        }
        return false;
    }
}

相应的，在struts-config.xml中加入controller元素

<controller>
 <set-property  property="processorClass"
 value="com.sample.util.CustomRequestProcessor"/>
</controller>

但刚才看到在Struts1.3中，已经不再使用RequestProcessor，而是用ComposableRequestProcessor 来实现自定义的request响应。

@Entity
@Table(name= "tc", catalog="first_hiber")
public class Tc {
      @org.hibernate.annotations.CollectionOfElements
      @JoinTable(name="tc_tracer", joinColumns=@JoinColumn(name="tc_id"))
      private Set<TcTracer> tcTracers = new HashSet<TcTracer>();

      @Id @GeneratedValue
      @Column(name="tc_id", nullable= false)
      private Long id;
}

  @Embeddable
  @Table(name="tc_tracer")
  public class TcTracer {
      @org.hibernate.annotations.Parent
      private Tc tc;
  
      @ManyToOne(cascade=CascadeType.ALL)
      @JoinColumn(name="tracer_id", nullable=false, updatable=false)
      private Tracer tracer;
  
      @ManyToOne(cascade=CascadeType.ALL)
      @JoinColumn(name="track_id", nullable=false, updatable=false)
      private Track track;
  }

如上，将TcTracer作为Tc的子元素，从而实现Tc的三相关联。

用HQL可以通过特定的Tc，Tracer得到对应的所有Track：

  select tctracers.track
  from Tc tc
      join tc.tcTracers tctracers
  where tc.name="tc name"
      and tctracers.tracer.name="tracer name"

 List<Track> tracks = session.createQuery(HQL).list();

起初以为是override hashCode()的方法不对。后来google查了查多数问题都出现在detached对象之后，再链接session由于对象的改变而出现的异常。

最后发现原来问题很简单....是在用annotation重写mapping的时候，忘记给@Id加上@GeneratedValue，导致第一个row insert后，再次insert时没有生成新的id！

看来annotation虽然方便了mapping，但由于和代码集中在一块了，很容易出现疏忽大意的错误，而且一般都不会注意到-.-

想起了python的SQLObject, SQLAlchemy，虽然功能没有Hibernate丰富，但是简单实用！

persion.getAddresses().add(address);
address.getPersons().add(person);

但对Hibernate而已，上面的代码会被转化为两条insert语句，

为了避免这样的情况出现需要定义inverse属性，告诉Hibernate persion和address之间的关系：

// !file: Person.class
public class Person {
    // ...
    @ManyToMany(
              targetEntity= Address.class,
              cascade = CascadeType.ALL,
      )
    @JoinTable(
              name="persion_address",
              joinColumns= {@JoinColumn(name="person_id")},
              inverseJoinColumns= {@JoinColumn(name="address_id")}
      )
      private Set<Address> adressses = new HashSet<Address> (0);
    // ...
}

// !file: Address.class
public class Address {
    // ...
    @ManyToMany(
            targetEntity= Persion.class,
            cascade = CascadeType.ALL, 
            mappedBy = "addresses"
    )
    private Set<Person> persons = new HashSet<Person>();
    // ...
}

上面的两个annotation告诉Hibernate，Person是主，对Address中persons属性的修改将不会产生SQL语句。

Hibernate里，如果是Many-to-many的关系，可以任意设置主class。

通常，还可以将添加删除关系的代码包装起来:

// !file: Person.class
public class Person {
    // ...
    public void addAddress(Address address) {
        this.getAddresses().add(address);
        address.getPersons().add(this);
    }
    public void removeAddress(Address address) {
        this.getAddresses().remove(address);
        address.getPersons().remove(this);
    }
    //...
} 

差不多把平时用的上的读完了，真感觉受益匪浅。不但详细的介绍了Hibernate的特性用法，而且其中介绍的ORM基本概念，灌输的ORM的思想也正是我所需要的。

对一个新手来说，business key, surrogate key, entity type, value type, transient, persistent, detached, persistence context...这些是什么概念，为什么要提出来，以及怎样实现的在书中都会有简单明了的解释。

不多说了，现在把书放出来，谁看谁知道;)

实际上使用Hibernate自带的工具hbm2ddl，建立根据你的对象建立数据库是很惬意的一件事;)

首先当然要建好POJO object, XML Mapping File(也可以使用工具根据POJO class建立)，配置文件(hibernate.cfg.xml)

然后运行下面的Java代码

import org.hibernate.cfg.Configuration; 
import org.hibernate.tool.hbm2ddl.SchemaExport;

public class SchemaUtil {
    public static void main(String[] args) {

        Configuration cfg = new Configuration().configure();
        SchemaExport schemaExport= new SchemaExport(cfg);
        schemaExport.create(false, true);
    }
}

Technorati : Hibernate, Java, database, persistence
Del.icio.us : Hibernate, Java, database, persistence

决定花几天时间好好的读读这本书，系统的学习Hibernate。

Technorati : Hibernate, Java, Persistence
Del.icio.us : Hibernate, Java, Persistence

1. 程序文件的编码；
2. 输出页面到客户端的编码；
3. 用户响应到服务器端的编码。

以设置为UTF-8为例，可以用如下方法解决。

1. 对于程序文件的编码

直接在Eclipse或者其他IDE，editor中将文件编码设为UTF-8即可。

2.输出页面

对于JSP页面，加入以下代码

<%@ page contentType="text/html; charset=UTF-8"%>
如果在IE或者Firefox中还不能正常显示，还可以在Html标识下加入下面的头信息

<meta http-equiv="Content-Type" content="text/html; charset=utf-8">

3. 响应到服务器端

我使用的是Tomcat，没有可以直接设置接受响应编码的方法(真是太佩服了!)，但可以通过写一个Filter实现编码转化。

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;

public class SetCharacterEncodingFilter implements Filter {

    protected String encoding = null;
    protected FilterConfig filterConfig = null;
    protected boolean ignore = true;

    public void destroy() {
        this.encoding = null;
        this.filterConfig = null;
    }

    public void doFilter(ServletRequest request, ServletResponse response,
                          FilterChain chain)
        throws IOException, ServletException {
        if (ignore || (request.getCharacterEncoding() == null)) {
            String encoding = selectEncoding(request);
            if (encoding != null)
                request.setCharacterEncoding(encoding);
        }
        chain.doFilter(request, response);
    }

    public void init(FilterConfig filterConfig) throws ServletException {
     this.filterConfig = filterConfig;
        this.encoding = filterConfig.getInitParameter("encoding");
        String value = filterConfig.getInitParameter("ignore");
        if (value == null)
            this.ignore = true;
        else if (value.equalsIgnoreCase("true"))
            this.ignore = true;
        else if (value.equalsIgnoreCase("yes"))
            this.ignore = true;
        else
            this.ignore = false;
    }

    protected String selectEncoding(ServletRequest request) {
        return (this.encoding);
    }
}

将SetCharacterEncodingFilter放到程序的编译目录下，再在web.xml中添加相应属性

    <filter>
        <filter-name>Set Character Encoding</filter-name>
        <filter-class>hijeff.filters.SetCharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>UTF-8</param-value>
        </init-param>
    </filter>
     
    <filter-mapping>
        <filter-name>Set Character Encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>    

Tomcat就会将用户通过HTTP响应的字符转化为UTF-8的编码了