阅读525 返回首页    go 京东网上商城

ssh搭建开发环境

公司一直不是ssh零配置的框架，每次写action都要在applicationcontext和struts里面配置，好麻烦，最近有空，写了一个ssh零配置的框架

这里写了一个小的项目，以用户权限管理为例

先做准备工作：

1.struts2去官网下载最新版struts开发包https://struts.apache.org/download.cgi

2.hibernate4去官网下载最新版hibernate4开发包https://sourceforge.net/projects/hibernate/files/hibernate4/

3.spring3去官网下载最新版spring3开发包https://www.springsource.org/download/community

一、先建立一个空的web的项目sshFrame，加载必须的包

1.添加struts2必备的包。我下载的是最近的struts2.3.8

asm-3.3.jar  --ASM字节码库 ，使用“cglib”则必要

aopalliance-1.0.jar  --这个包为AOP提供了最普通和通用的接口

commons-fileupload-1.2.2.jar   --Struts2上传下载的jar

commons-io-2.0.1.jar  --Struts2上传下载的jar

commons-logging-1.1.1.jar   --Jakarta的通用日志记录包

freemarker-2.3.19.jar

ognl-3.0.6.jar    --支持ognl表达式

struts2-core-2.3.8.jar  --struts2的核心包

struts2-spring-plugin-2.3.8.jar     --struts2与spring整合所需

struts2-convention-plugin-2.3.8.jar  --struts2零配置注释用

xwork-core-2.3.8.jar 

可以不加 struts2-config-browser-plugin-2.3.8.jar为struts协助开发需要的包：可以输入https://127.0.0.1:8686/config-browser/actionNames.action查看系统所有已经存在的action,配置不正确就可以在这里看出来;

2.添加Hibernate 所需要的包。hibernate-4.1.9.Final

把下载下来的hibernate\lib\required下的包全部拷贝进去，分别是

antlr-2.7.7.jar  --语言转换工具，hibernate用他将hql语句转换为sql语句

dom4j-1.6.1.jar  --解析xml文档的工具

hibernate-commons-annotations-4.0.1.Final.jar

hibernate-core-4.1.9.Final.jar  --核心包

hibernate-jpa-2.0-api-1.0.1.Final.jar

javassist-3.17.1-GA.jar

jboss-logging-3.1.0.GA.jar

jboss-transaction-api_1.1_spec-1.0.0.Final.jar

还有加入hibernate\lib\optional\c3p0\c3p0-0.9.1.jar

hibernate-ehcache-4.1.9.Final.jar

ehcache-core-2.4.3.jar

slf4j-api-1.6.4.jar

slf4j-log4j12-1.6.4.jar

3添加spring3 所需要的包 spring-framework-3.2.0.RELEASE

spring-aop-3.2.0.RELEASE.jar

spring-aspects-3.2.0.RELEASE.jar

spring-beans-3.2.0.RELEASE.jar

spring-context-3.2.0.RELEASE.jar

spring-core-3.2.0.RELEASE.jar

spring-expression-3.2.0.RELEASE.jar

spring-instrument-3.2.0.RELEASE.jar

spring-jdbc-3.2.0.RELEASE.jar

spring-jms-3.2.0.RELEASE.jar

spring-orm-3.2.0.RELEASE.jar

spring-oxm-3.2.0.RELEASE.jar

spring-test-3.2.0.RELEASE.jar --测试时用

spring-tx-3.2.0.RELEASE.jar  --事务处理所用

spring-web-3.2.0.RELEASE.jar

aspectjweaver-1.5.3.jar  --spring所依赖的包

 

其他

asm-commons-3.3.jar

Commons—pool.jar ,commons-dbcp.jar  ----------DBCP数据库连接池，Apache的jakarta组织开发 的，tomcat连接池也是dbcp（可选）

cglib.jar----------------------------高效的代码生成工具, Hibernate用它在运行时扩展 Java类和实现 Java 接

jta.jar  --标准的JTA API(JTA即java事物API，JTA事务比JDBC事务更强大。一个JTA事务可以有多个参与者，而一个JDBC事务则被限定在一个单一的数据库连接)，我暂时还没加，先备着

mysql-connector-java-5.1.18-bin.jar

log4j-1.2.16.jar

二、添加配置文件

在struts包下struts\src\apps\blank\src\main\resources提供了空白的struts.xml文件，把它复制到项目的src下

web.xml中

  1. <!-- spring 配置 -->  
  2.   <listener>  
  3.     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
  4.   </listener>  
  5.   <context-param>  
  6.     <description>Spring上下文</description>  
  7.     <param-name>contextConfigLocation</param-name>  
  8.     <param-value>classpath:applicationContext*.xml</param-value>  
  9.   </context-param>  
  10.   
  11. <!-- hibernate 懒加载的问题过滤 ,可以不配置 -->  
  12.   <filter>  
  13.     <description>hibernate Session 过滤器</description>  
  14.     <filter-name>openSessionInViewFilter</filter-name>  
  15.     <filter-class>org.springframework.orm.hibernate4.support.OpenSessionInViewFilter</filter-class>  
  16.   </filter>  
  17.   <filter-mapping>  
  18.     <filter-name>openSessionInViewFilter</filter-name>  
  19.     <url-pattern>/*</url-pattern>  
  20.   </filter-mapping>  
  21.   <filter>   
  22.  <!-- struts配置 -->  
  23.     <filter-name>struts2</filter-name>  
  24.     <filter-class>org.apache.struts2.dispatcher.ng.filter.StrutsPrepareAndExecuteFilter</filter-class>  
  25.   </filter>  
  26.   <filter-mapping>  
  27.     <filter-name>struts2</filter-name>  
  28.     <url-pattern>/*</url-pattern>  
  29.   </filter-mapping>  
  30.   
  31.    

struts.xml配置

  1. <struts>  
  2.   
  3. <!-- 使用Spring -->  
  4.  <constant name="struts.objectFactory" value="spring" />  
  5.  <constant name="struts.devMode" value="true" />  
  6.  <constant name="struts.configuration.xml.reload" value="true" />  
  7.    
  8.  <package name="default" extends="struts-default" namespace="/">  
  9.   <interceptors>  
  10.    <!-- 使用权限拦截 -->  
  11.    <interceptor name="authority" class="com.sshFrame.zero.interceptor.AuthorityInterceptor"/>  
  12.    <!-- 异常拦截 -->  
  13.    <interceptor name="exceptionInterceptor" class="com.sshFrame.zero.interceptor.ExceptionInterceptor"/>  
  14.    <!-- 解决struts安全漏洞，拦截所有的带有#号的url -->  
  15.    <interceptor-stack name="baseStack">  
  16.     <interceptor-ref name="authority"/>  
  17.     <interceptor-ref name="exceptionInterceptor"/>  
  18.     <interceptor-ref name="params">     
  19.      <param name="excludeParams">.*\\u0023.*</param>     
  20.     </interceptor-ref>  
  21.     <interceptor-ref name="defaultStack"/>  
  22.    </interceptor-stack>  
  23.   </interceptors>  
  24.   <!-- 配置默认拦截器栈 -->  
  25.   <default-interceptor-ref name="baseStack"/>  
  26.   <global-results>  
  27.    <result name="login">/index.jsp</result>  
  28.    <result name="error">/error.jsp</result>  
  29.   </global-results>  
  30.  </package>  
  31.   
  32. </struts>  

 applicationcontext.xml配置：

  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="https://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"   
  4.     xmlns:p="https://www.springframework.org/schema/p"  
  5.     xmlns:context="https://www.springframework.org/schema/context"  
  6.     xmlns:aop="https://www.springframework.org/schema/aop"   
  7.     xmlns:tx="https://www.springframework.org/schema/tx"  
  8.     xmlns:dwr="https://www.directwebremoting.org/schema/spring-dwr"  
  9.     xsi:schemaLocation="https://www.springframework.org/schema/beans   
  10.     https://www.springframework.org/schema/beans/spring-beans-3.2.xsd  
  11.     https://www.springframework.org/schema/context   
  12.     https://www.springframework.org/schema/context/spring-context-3.2.xsd  
  13.     https://www.springframework.org/schema/aop  
  14.     https://www.springframework.org/schema/aop/spring-aop-3.2.xsd  
  15.     https://www.springframework.org/schema/tx  
  16.     https://www.springframework.org/schema/tx/spring-tx-3.2.xsd">  
  17.   
  18.     <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">  
  19.         <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>  
  20.         <property name="url" value="jdbc:mysql://127.0.0.1:3306/osdesignaid"></property>  
  21.         <property name="username" value="root"></property>  
  22.         <property name="password" value="root"></property>  
  23.     </bean>  
  24.     <bean id="sessionFactory"  
  25.         class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">  
  26.         <property name="dataSource" ref="dataSource" />  
  27.         <property name="hibernateProperties">  
  28.             <props>  
  29.                 <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>  
  30.                 <prop key="hibernate.current_session_context_class">thread</prop>  
  31.                 <prop key="hibernate.cache.region.factory_class">org.hibernate.cache.EhCacheRegionFactory</prop>  
  32.                 <prop key="hibernate.show_sql">true</prop>  
  33.                 <prop key="hibernate.format_sql">true</prop>  
  34.                 <prop key="hibernate.hbm2ddl.auto">update</prop>  
  35.             </props>  
  36.         </property>  
  37.         <property name="packagesToScan">  
  38.             <list>  
  39.                 <value>com.sshFrame.zero.pojo</value>  
  40.                 <value>com.sshFrame.test.pojo</value>  
  41.                 </list>  
  42.         </property>  
  43.     </bean>  
  44.     <aop:aspectj-autoproxy /><!-- 代理 -->  
  45.     <!-- 定义事务管理器 -->  
  46.     <bean id="txManager"  class="org.springframework.orm.hibernate4.HibernateTransactionManager">  
  47.         <property name="sessionFactory" ref="sessionFactory" />  
  48.     </bean>  
  49.     <!-- 申明annotation 加载事务驱动 -->  
  50.     <tx:annotation-driven transaction-manager="txManager" proxy-target-class="true"/>  
  51.     <tx:advice id="txAdvice" transaction-manager="txManager">  
  52.         <tx:attributes>  
  53.             <tx:method name="save*" propagation="REQUIRED" />  
  54.             <tx:method name="add*" propagation="REQUIRED" />  
  55.             <tx:method name="create*" propagation="REQUIRED" />  
  56.             <tx:method name="insert*" propagation="REQUIRED" />  
  57.             <tx:method name="update*" propagation="REQUIRED" />  
  58.             <tx:method name="merge*" propagation="REQUIRED" />  
  59.             <tx:method name="del*" propagation="REQUIRED" />  
  60.             <tx:method name="remove*" propagation="REQUIRED" />  
  61.             <tx:method name="put*" propagation="REQUIRED" />  
  62.             <tx:method name="use*" propagation="REQUIRED"/>  
  63.   
  64.             <!--hibernate4必须配置为开启事务 否则 getCurrentSession()获取不到-->  
  65.             <tx:method name="get*" propagation="REQUIRED" read-only="true" />  
  66.             <tx:method name="count*" propagation="REQUIRED" read-only="true" />  
  67.   
  68.             <tx:method name="find*" propagation="REQUIRED" read-only="true" />  
  69.             <tx:method name="list*" propagation="REQUIRED" read-only="true" />  
  70.   
  71.             <tx:method name="*" read-only="true" />  
  72.         </tx:attributes>  
  73.     </tx:advice>  
  74.     <aop:config expose-proxy="true">  
  75.         <!-- 只对业务逻辑层实施事务 -->  
  76.         <aop:pointcut id="txPointcut" expression="execution(* cn.javass..service..*.*(..))" />  
  77.         <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointcut"/>  
  78.     </aop:config>  
  79.     <!-- 自动扫描包 -->  
  80.     <context:annotation-config />  
  81.     <context:component-scan base-package="com.sshFrame.zero.*,com.sshFrame.test.*" annotation-config="true"/>  
  82. </beans>  

三、写框架基类

改写基本的框架类了

Basedao

  1. package com.sshFrame.zero.dao;  
  2.   
  3. import java.io.Serializable;  
  4. import java.lang.reflect.Field;  
  5. import java.lang.reflect.ParameterizedType;  
  6. import java.lang.reflect.Type;  
  7. import java.util.List;  
  8.   
  9. import javax.persistence.Id;  
  10.   
  11. import org.hibernate.Criteria;  
  12. import org.hibernate.HibernateException;  
  13. import org.hibernate.Query;  
  14. import org.hibernate.Session;  
  15. import org.hibernate.SessionFactory;  
  16. import org.hibernate.criterion.Example;  
  17. import org.springframework.beans.factory.annotation.Autowired;  
  18.   
  19. /**  
  20.  * 基于hibernate的BaseDao  
  21.  * Spring3对Hibernate4已经没有了HibernateDaoSupport和HibernateTemplate的支持，使用了原生态的API  
  22.  * @author 雪精灵  
  23.  *  
  24.  * @param <T>  
  25.  */  
  26. public class BaseDao<T extends Serializable> {  
  27.     @Autowired  
  28.     private SessionFactory sessionFactory;  
  29.     //当前泛型类  
  30.     @SuppressWarnings("rawtypes")  
  31.     private Class entityClass;  
  32.     //当前主键名称  
  33.     private String pkname;  
  34.     private final String HQL_LIST_ALL;  
  35.     private final String HQL_COUNT_ALL;  
  36.     @SuppressWarnings("rawtypes")  
  37.     public Class getEntityClass() {  
  38.         return entityClass;  
  39.     }  
  40.     @SuppressWarnings("rawtypes")  
  41.     public void setEntityClass(Class entityClass) {  
  42.         this.entityClass = entityClass;  
  43.     }  
  44.       
  45.     @SuppressWarnings("rawtypes")  
  46.     public BaseDao() {  
  47.         //获取当前泛型类  
  48.         Type type = this.getClass().getGenericSuperclass();  
  49.         if (type.toString().indexOf("BaseDao") != -1) {  
  50.             ParameterizedType type1 = (ParameterizedType) type;  
  51.             Type[] types = type1.getActualTypeArguments();  
  52.             setEntityClass((Class) types[0]);  
  53.         }else{  
  54.             type = ((Class)type).getGenericSuperclass();  
  55.             ParameterizedType type1 = (ParameterizedType) type;  
  56.             Type[] types = type1.getActualTypeArguments();  
  57.             setEntityClass((Class) types[0]);  
  58.         }  
  59.         getPkname();  
  60.         HQL_LIST_ALL="from "+this.entityClass.getSimpleName()+" order by "+pkname+" desc";  
  61.         HQL_COUNT_ALL="select count(*) from "+this.entityClass.getSimpleName();  
  62.     }  
  63.     /**  
  64.      * 获取主键名称  
  65.      * @return  
  66.      */  
  67.     public String getPkname() {  
  68.         Field[] fields = this.entityClass.getDeclaredFields();//反射类字段  
  69.         for (Field field : fields) {  
  70.             field.isAnnotationPresent(Id.class);  
  71.             this.pkname=field.getName();  
  72.             break;  
  73.         }  
  74.         return pkname;  
  75.     }  
  76.     /**  
  77.      * 保存实例  
  78.      *   
  79.      * @param t  
  80.      * @throws HibernateException  
  81.      */  
  82.     public void save(T t) throws HibernateException{  
  83.         Session session=null;  
  84.         try {  
  85.             session=sessionFactory.openSession();  
  86.             session.beginTransaction();  
  87.             session.save(t);  
  88.             session.getTransaction().commit();  
  89.         } catch (HibernateException e) {  
  90.             e.printStackTrace();  
  91.             throw new HibernateException(e);  
  92.         }finally{  
  93.             session.close();  
  94.         }  
  95.     }  
  96.     /**  
  97.      * 修改实例  
  98.      *   
  99.      * @param t  
  100.      * @throws HibernateException  
  101.      */  
  102.     public void update(T t) throws HibernateException{  
  103.         Session session=null;  
  104.         try {  
  105.             session=sessionFactory.openSession();  
  106.             session.beginTransaction();  
  107.             session.update(t);  
  108.             session.getTransaction().commit();  
  109.         } catch (HibernateException e) {  
  110.             e.printStackTrace();  
  111.             throw new HibernateException(e);  
  112.         }finally{  
  113.             session.close();  
  114.         }  
  115.     }  
  116.       
  117.     /**  
  118.      * 删除实例  
  119.      *   
  120.      * @param t  
  121.      * @throws HibernateException  
  122.      */  
  123.     public void delete(T t) throws HibernateException{  
  124.         Session session=null;  
  125.         try {  
  126.             session=sessionFactory.openSession();  
  127.             session.beginTransaction();  
  128.             session.delete(t);  
  129.             session.getTransaction().commit();  
  130.         } catch (HibernateException e) {  
  131.             e.printStackTrace();  
  132.             throw new HibernateException(e);  
  133.         }finally{  
  134.             session.close();  
  135.         }  
  136.     }  
  137.     /**  
  138.      * 获取实例  
  139.      *   
  140.      * @param id  
  141.      * @throws HibernateException  
  142.      */  
  143.     @SuppressWarnings("unchecked")  
  144.     public T get(Serializable id) throws Exception{  
  145.         Session session=null;  
  146.         T t=null;  
  147.         try {  
  148.             session=sessionFactory.openSession();  
  149.             session.beginTransaction();  
  150.             t=(T) session.get(getEntityClass(), id);  
  151.             session.getTransaction().commit();  
  152.         } catch (HibernateException e) {  
  153.             e.printStackTrace();  
  154.             throw new HibernateException(e);  
  155.         }finally{  
  156.             session.close();  
  157.         }  
  158.         return t;  
  159.     }  
  160.     /**  
  161.      * 查询全部  
  162.      *   
  163.      * @throws HibernateException  
  164.      */  
  165.     @SuppressWarnings("unchecked")  
  166.     public List<T> findAll() throws Exception {  
  167.         List<T> list=null;  
  168.         Session session=null;  
  169.         try {  
  170.             session = sessionFactory.openSession();  
  171.             session.beginTransaction();  
  172.             Query query = session.createQuery(HQL_LIST_ALL);  
  173.             list = query.list();  
  174.             session.getTransaction().commit();  
  175.         } catch (HibernateException e) {  
  176.             e.printStackTrace();  
  177.         }finally{  
  178.             session.close();  
  179.         }  
  180.         return list;  
  181.     }  
  182.     /**  
  183.      * 查询总数  
  184.      *   
  185.      * @throws HibernateException  
  186.      */  
  187.     public Integer findAllCount() throws Exception {  
  188.         Session session=null;  
  189.         Integer count=0;  
  190.         try {  
  191.             session = sessionFactory.openSession();  
  192.             session.beginTransaction();  
  193.             Query query = session.createQuery(HQL_COUNT_ALL);  
  194.             List<?> list = query.list();  
  195.             session.getTransaction().commit();  
  196.             if(list!=null&&!list.isEmpty()){  
  197.                 count=((Integer) list.get(0)).intValue();  
  198.             }  
  199.         } catch (HibernateException e) {  
  200.             e.printStackTrace();  
  201.         }finally{  
  202.             session.close();  
  203.         }  
  204.         return count;  
  205.     }  
  206.     /**  
  207.      * QBC查询  
  208.      *   
  209.      * @param criteria  
  210.      * @throws HibernateException  
  211.      */  
  212.     @SuppressWarnings("unchecked")  
  213.     public List<T> findByCriteria(Criteria criteria) throws Exception {  
  214.         List<T> list=null;  
  215.         Session session=null;  
  216.         try {  
  217.             session = sessionFactory.openSession();  
  218.             session.beginTransaction();  
  219.             Criteria criteria1 = session.createCriteria(getEntityClass());  
  220.             criteria1=criteria;  
  221.             list = criteria1.list();  
  222.             session.getTransaction().commit();  
  223.         } catch (HibernateException e) {  
  224.             e.printStackTrace();  
  225.         }finally{  
  226.             session.close();  
  227.         }  
  228.         return list;  
  229.     }  
  230.       
  231.     /**  
  232.      * QBE查询  
  233.      *   
  234.      * @param t  
  235.      * @throws HibernateException  
  236.      */  
  237.     @SuppressWarnings("unchecked")  
  238.     public List<T> findByExample(T t) throws Exception {  
  239.         List<T> list=null;  
  240.         Session session=null;  
  241.         Example example = Example.create(t);  
  242.         try {  
  243.             session = sessionFactory.openSession();  
  244.             session.beginTransaction();  
  245.             Criteria criteria = session.createCriteria(getEntityClass());  
  246.             criteria.add(example);  
  247.             list = criteria.list();  
  248.             session.getTransaction().commit();  
  249.         } catch (HibernateException e) {  
  250.             e.printStackTrace();  
  251.         }finally{  
  252.             session.close();  
  253.         }  
  254.         return list;  
  255.     }  
  256.     /**  
  257.      * HQL查询  
  258.      *   
  259.      * @param hql  
  260.      * @param objects  
  261.      * @throws HibernateException  
  262.      */  
  263.     @SuppressWarnings("unchecked")  
  264.     public List<Object[]> findByHql(String hql,final Object...objects) throws Exception{  
  265.         List<Object[]> list=null;  
  266.         Session session=null;  
  267.         try {  
  268.             session=sessionFactory.openSession();  
  269.             session.beginTransaction();  
  270.             Query query = session.createQuery(hql);  
  271.             for (int i = 0; i < objects.length; i++) {  
  272.                 query.setParameter(i, objects[i]);  
  273.             }  
  274.             list = query.list();  
  275.             session.getTransaction().commit();  
  276.         } catch (Exception e) {  
  277.             e.printStackTrace();  
  278.         }finally{  
  279.             session.close();  
  280.         }  
  281.         return list;  
  282.     }  
  283.     /**  
  284.      * SQL查询  
  285.      *   
  286.      * @param hql  
  287.      * @param objects  
  288.      * @throws HibernateException  
  289.      */  
  290.     @SuppressWarnings("unchecked")  
  291.     public List<Object[]> findBySql(String sql,final Object...objects){  
  292.         List<Object[]> list=null;  
  293.         Session session=null;  
  294.         try {  
  295.             session=sessionFactory.openSession();  
  296.             session.beginTransaction();  
  297.             Query query = sessionFactory.getCurrentSession().createSQLQuery(sql);  
  298.             for (int i = 0; i < objects.length; i++) {  
  299.                 query.setParameter(i, objects[i]);  
  300.             }  
  301.             list = query.list();  
  302.             session.getTransaction().commit();  
  303.         } catch (Exception e) {  
  304.             e.printStackTrace();  
  305.         }finally{  
  306.             session.close();  
  307.         }  
  308.         return list;  
  309.     }  
  310. }  


BaseService

  1. package com.sshFrame.zero.service;  
  2.   
  3. import java.io.Serializable;  
  4. import java.util.List;  
  5.   
  6. import com.sshFrame.zero.dao.BaseDao;  
  7. /**  
  8.  * @author 雪精灵  
  9.  *  
  10.  * @param <t>  
  11.  */  
  12.   
  13. public class BaseService<T extends Serializable> {  
  14.       
  15.     protected BaseDao<T> baseDao;  
  16.       
  17.     public void save(T t) throws Exception{  
  18.         baseDao.save(t);  
  19.     }  
  20.     public void update(T t) throws Exception{  
  21.         baseDao.update(t);  
  22.     }  
  23.     public void delete(T t) throws Exception{  
  24.         baseDao.delete(t);  
  25.     }  
  26.     public T get(Serializable id) throws Exception{  
  27.         return baseDao.get(id);  
  28.     }  
  29.     public List<T> findAll() throws Exception{  
  30.         return baseDao.findAll();  
  31.     }  
  32.     public List<T> findByExample(T t) throws Exception{  
  33.         return baseDao.findByExample(t);  
  34.     }  
  35.     public BaseDao<T> getBaseDao() {  
  36.         return baseDao;  
  37.     }  
  38.     public void setBaseDao(BaseDao<T> baseDao) {  
  39.         this.baseDao = baseDao;  
  40.     }  
  41. }</t>  

 

四、写7个pojo

  1. package com.sshFrame.zero.pojo;  
  2.   
  3. import java.io.Serializable;  
  4. import java.util.HashSet;  
  5. import java.util.Set;  
  6.   
  7. import javax.persistence.CascadeType;  
  8. import javax.persistence.Column;  
  9. import javax.persistence.Entity;  
  10. import javax.persistence.FetchType;  
  11. import javax.persistence.GeneratedValue;  
  12. import javax.persistence.Id;  
  13. import javax.persistence.OneToMany;  
  14. import javax.persistence.Table;  
  15.   
  16. import org.hibernate.annotations.GenericGenerator;  
  17.   
  18. @Entity  
  19. @Table(name="userinfo")  
  20. public class Userinfo implements Serializable{  
  21.     private static final long serialVersionUID = 1L;  
  22.     private String userid;  
  23.     private String username;  
  24.     private String password;  
  25.     private String depid;  
  26.     private String dutyid;  
  27.     private Set<Userrole> userroles=new HashSet<Userrole>();  
  28.     @GenericGenerator(name = "generator", strategy = "uuid")  
  29.     @Id  
  30.     @GeneratedValue(generator = "generator")  
  31.     @Column(name = "userid", unique = true, nullable = false, length = 50)  
  32.     public String getUserid() {  
  33.         return userid;  
  34.     }  
  35.     public void setUserid(String userid) {  
  36.         this.userid = userid;  
  37.     }  
  38.     @Column(name = "username", nullable = false, length = 50)  
  39.     public String getUsername() {  
  40.         return username;  
  41.     }  
  42.     public void setUsername(String username) {  
  43.         this.username = username;  
  44.     }  
  45.     @Column(name = "password", nullable = false, length = 50)  
  46.     public String getPassword() {  
  47.         return password;  
  48.     }  
  49.     public void setPassword(String password) {  
  50.         this.password = password;  
  51.     }  
  52.     @Column(name = "depid", nullable = false, length = 50)  
  53.     public String getDepid() {  
  54.         return depid;  
  55.     }  
  56.     public void setDepid(String depid) {  
  57.         this.depid = depid;  
  58.     }  
  59.     @Column(name = "dutyid", nullable = false, length = 50)  
  60.     public String getDutyid() {  
  61.         return dutyid;  
  62.     }  
  63.     public void setDutyid(String dutyid) {  
  64.         this.dutyid = dutyid;  
  65.     }  
  66.     @OneToMany(cascade=CascadeType.REMOVE,mappedBy="userinfo",fetch=FetchType.LAZY)  
  67.     public Set<Userrole> getUserroles() {  
  68.         return userroles;  
  69.     }  
  70.     public void setUserroles(Set<Userrole> userroles) {  
  71.         this.userrol

    最后更新：2017-04-04 07:36:14

      上一篇：go Oracle 查询表中各列名称、表中列数
      下一篇：go WinFrom 控件 属性 小结