ssh整理

工欲善其事，必先利其器

Struts2依赖包（struts-2.1.8.1）

1 struts2-core-2.1.8.1.jar struts2框架的核心类库

2 xwork-core-2.1.6.jar xwork类库，struts2在其上构建

3 ognl-2.7.3.jar 对象图导航语言（Object Graph Navigation Languge），struts2框架通过其读写对象的属性

4 freemarker-2.3.15.jar struts2的UI标签的模板使用FreeMarker编写

5 commons-logging-1.0.4.jar ASF出品的日志包，Struts2框架使用这个日志包来支持Log4J和JDK1.4+的日志记录

6 commons-fileupload-1.2.1.jar 文件上传组件，2.1.6版本后必须加入此文件

Struts2 默认的配置文件为struts.xml，该文件需要存放在WEB-INF/classes下、
文件模板:

"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"
"http://struts.apache.org/dtds/struts-2.0.dtd">

模板还可在struts包中的例子中查看

struts-2.1.8.1-all\struts-2.1.8.1\apps\struts2-blank-2.1.8.1\WEB-INF\classes\struts.xml

Struts2 框架是通过Filter启动的，在web.xml中配置：

    <filter-name>struts2</filter-name>

    <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>

org.apache.struts2.dispatcher.ng. FilterDispatcher –>

</filter>

<filter-mapping>
    <filter-name>struts2</filter-name>
    <url-pattern>/*</url-pattern>

在StrutsPrepareAndExecuteFilter的init()方法中将会读取类路径下默认的配置文件struts.xml完成初始化操作。

Struts2读取到struts.xml的内容后，以javabean形式存放在内存中，以后struts2对用户的每次请求处理将使用内存中的数据，而不是每次都读取struts2.xml文件。

Hibernate 依赖包 3.5.3

hibernate3.jar

antlr-2.7.6.jar

cglib-2.2.jar

commons-collections-3.1.jar

commons-logging-1.0.4.jar

jta-1.1.jar

dom4j-1.6.1.jar

javassist-3.9.0.GA.jar

slf4j-api-1.5.8.jar

slf4j-nop-1.6.1.jar

backport-util-concurrent-3.1.jar

ehcache-1.5.0.jar

hibernate.cfg.xml

"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<property name="connection.username">root</property>

<property name="connection.url">
    jdbc:mysql://localhost:3306/fuxi    </property>
<property name="dialect">
    org.hibernate.dialect.MySQLDialect
</property>
<property name="myeclipse.connection.profile">mysql</property>
<property name="connection.password">zhao</property>
<property name="connection.driver_class">
    com.mysql.jdbc.Driver
</property>
<property name="hbm2ddl.auto">update</property>
<property name="show_sql">true</property>
<!-- 配置二级缓存 -->
 <property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
<mapping resource="com/hibernate/pojo/Dpojo.hbn.xml" />

Dpojo.hbm.xml

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

–>

   <generator class="increment"></generator> 

HibernateUtil.java

package com.util;

import java.io.Serializable;

import org.hibernate.HibernateException;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.hibernate.Transaction;

import org.hibernate.cfg.Configuration;

public final class HibernateUtil {

private static SessionFactory sessionFactory;

private HibernateUtil(){

}
static{
    Configuration cfg=new Configuration();
    cfg.configure();
    sessionFactory=cfg.buildSessionFactory();
}

//SessionFactory

public static SessionFactory getSessionFactory(){

  return sessionFactory;

}

//Session

public static Session getSession(){

  return sessionFactory.openSession();

}

//添加

public static void add(Object entity){

    Session s=null;
    Transaction ts=null;
    try{
    s=HibernateUtil.getSession();
    ts=s.beginTransaction();
    s.save(entity);//没提交事务的前提下，save方法执行插入语句，再回滚删除
    ts.commit();
    }catch(HibernateException e){
        if(ts!=null){
            ts.rollback();
            throw e;
        }
    }finally{
        if(s!=null){
            s.close();
        }
    }

}
//修改
public static void update(Object entity){

    Session s=null;
    Transaction ts=null;
    try{
    s=HibernateUtil.getSession();
    ts=s.beginTransaction();
    s.update(entity);//没提交事务的前提下，save方法执行插入语句，再回滚删除
    ts.commit();
    }catch(HibernateException e){
        if(ts!=null){
            ts.rollback();
            throw e;
        }
    }finally{
        if(s!=null){
            s.close();
        }
    }

}

//删除

public static void delete(Object entity){

    Session s=null;
    Transaction ts=null;
    try{
    s=HibernateUtil.getSession();
    ts=s.beginTransaction();
    s.delete(entity);//没提交事务的前提下，save方法执行插入语句，再回滚删除
    ts.commit();
    }catch(HibernateException e){
        if(ts!=null){
            ts.rollback();
            throw e;
        }
    }finally{
        if(s!=null){
            s.close();
        }
    }

}

//查

public static Object get(Class clazz, Serializable id){

  Session s=null;
  try{
      s=HibernateUtil.getSession();
      Object obj=s.get(clazz, id);
      return obj;
  }finally{
      if(s!=null){
          s.close();
      }
  }

}

}

Hibernate对应关系

一对多，

一个部门多个员工，多个员工在一个部门

class Dept{
private int id;
private Set emp = new HashSet ();
}

class Emp{
private int id;
private int deptid;
private Dept dept;
}

Dept.hbm.xml

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

   <!-- <generator class="assigned"></generator> 指定表的主键的管理方式
  -->
  <generator class="sequence">
  <param name="sequence">seq_release</param>
  </generator>

 <key>
   <column name="deptid"></column>
 </key>
 <!-- 一对多 -->
 <one-to-many class="Emp"/>

Emp.hbm.xml

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

 <generator class="sequence">
  <param name="sequence">seq_book</param>
</generator>

 <column name="deptid"></column>

多对多，拆成两个一对多。

Cour.hbm.xml
inverse=“true”>

 <key column="cid"></key>
 <many-to-many class="Student" column="sid"></many-to-many>

Stu.hbm.xml

<set name="course" table="student_course_link" cascade="all">
 <key column="sid"></key>
 <many-to-many class="Course" column="cid"></many-to-many>
</set>

一对一 也可以 一对多表示。

Spring2.5依赖包

dist\spring.jar

lib\jakarta-commons\commons-logging.jar

lib\aspectj\aspectjweaver.jar 和 aspectjrt.jar 切面编程AOP

lib\cglib\cglib-nodep-2.1.3.jar

lib\j2ee\common-annotations.jar 注解

web.xml需加载

<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:application*.xml</param-value>
</context-param>
<!-- 通过监听器加载applicationContext.xml -->
<listener>
    <listener-class>
        org.springframework.web.context.ContextLoaderListener
    </listener-class>
</listener>

获取bean

public static void main(String[] args) {

    ApplicationContext context=new ClassPathXmlApplicationContext(
            new String[]{"applicationContext.xml"});
    DBService service=(DBService)context.getBean("dbService");
    service.query();

}

<beans xmlns=“http://www.springframework.org/schema/beans”

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"
default-lazy-init="true">


<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="locations" value="classpath:config.properties" />
</bean>

<!-- 数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">

    <property name="driverClass" value="${jdbc.driverClassName}"></property>
    <property name="jdbcUrl" value="${jdbc.url}"></property>
    <property name="user" value="${jdbc.username}"></property>
    <property name="password" value="${jdbc.password}"></property>

    <!-- 从数据库获取新连接失败后重复尝试的次数 -->
    <property name="acquireIncrement" value="2" />
    <!-- 是否自动提交 -->
    <property name="autoCommitOnClose" value="false"></property>
    <!-- 指定连接池的超时时长 -->
    <property name="checkoutTimeout" value="1000"></property>
    <!-- 隔多少秒检查所有连接池中的空闲连接 -->
    <property name="idleConnectionTestPeriod" value="3000"></property>
    <!-- 初始化几个链接池 -->
    <property name="initialPoolSize" value="5"></property>
    <!-- 连接池连接的最大空闲时间 -->
    <property name="maxIdleTime" value="5000"></property>
    <!-- 连接数据库池的最大连接数 -->
    <property name="maxPoolSize" value="100"></property>
    <!-- 连接数据库池的最小连接数 -->
    <property name="minPoolSize" value="2"></property>
</bean>
<bean id="sessionFactory"
    class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
    <property name="dataSource">
        <ref bean="dataSource" />
    </property>
    <property name="hibernateProperties">
        <props>
            <!-- hibernate连接方言 -->
            <prop key="hibernate.dialect">${hibernate.dialect}</prop>
            <!-- 启动时是否创建数据库表 
                            <prop key="hibernate.hbm2ddl.auto">update</prop>-->
            <!-- 调试时显示sql语句 -->
            <prop key="hibernate.show_sql">false</prop>
            <!-- 将sql脚本格式化后再输出 -->
            <prop key="hibernate.format_sql">false</prop>
            <!-- 生成调试注释 -->
            <prop key="hibernate.use_sql_comments">false</prop>
            <prop key="hibernate.jdbc.fetch_size">100</prop>
            <prop key="hibernate.jdbc.batch_size">30</prop>

            <!-- 启用查询缓存 -->
            <prop key="hibernate.cache.use_query_cache">true</prop>
            <!-- 启用二级缓存 -->
            <prop key="hibernate.cache.use_second_level_cache">true</prop>
            <!-- 启用缓存管理 -->
            <prop key="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</prop>
        </props>
    </property>
    <property name="mappingResources">
        <list>
        <!-- 人事模块 -->
            <!-- 人员表 -->
            <value>cn/net/Employeelist.hbm.xml</value>

        </list>    
    </property>
</bean>

<!--  声明事务管理-->
<bean id="transactionManager"
    class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory" />
</bean>
<!-- 定义事务拦截规则 -->
<bean id="baseTransactionProxy" abstract="true"
    class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    <property name="transactionManager" ref="transactionManager" />
    <property name="transactionAttributes">
        <props>
        <!-- 
            <prop key="save*">
                PROPAGATION_REQUIRED,-Exception,+DataAccessException
            </prop>
            <prop key="delete*">
                PROPAGATION_REQUIRED,-Exception,+DataAccessException
            </prop>
            <prop key="update*">
                PROPAGATION_REQUIRED,-Exception,+DataAccessException
            </prop>
            <prop key="execute*">
                PROPAGATION_REQUIRED,-Exception,+DataAccessException
            </prop>
            <prop key="batch*">
                PROPAGATION_REQUIRED,-Exception,+DataAccessException
            </prop>
            <prop key="insert*">
                PROPAGATION_REQUIRED,-Exception,+DataAccessException
            </prop>
            <prop key="modify*">
                PROPAGATION_REQUIRED,-Exception,+DataAccessException
            </prop>
            <prop key="*">
                PROPAGATION_REQUIRED,readOnly,-DataAccessException
            </prop>
        -->
        <!-- 
            由于前期方法名定义不规范，当前开放所有命名有数据操作权限，
            但是发生Exception及其子类异常时程序将会强制回滚事物操作。
         -->
        <prop key="*">
                PROPAGATION_REQUIRED,-Exception,-DataAccessException
            </prop>
        </props>
    </property>
</bean>