《跟我一起做J2EE版Blog–jPress》4（搭建marven下的Spring和Hibernate）

柔情只为你懂 2021-11-11 14:38 157阅读 0赞

jPress使用SSH的最新版本来开发，分别是Struts2.3.1,Spring3.1.1和Hibernate4.1.1，此外还将涉及Freemarker模板引擎来进行显示层的制作。在marven中配置SSH环境只需要编写好pom.xml文件即可，我们利用myeclipse为项目添加SSH特性的时候不要引入任何jar包。marven在build项目时会帮助我们自动引入所需的各种jar包，如果本地库中没有所需jar包，marven会从它的中央库中下载过来保存进本地库。上一章中我已经贴出了我目前的pom.xml文件，随着项目的推进，期间可能需要引入其他jar包，除非有重大的改变，我这里就不再对pom.xml赘述了。JAVA项目的设计层次很重要，层次的引入会降低项目的耦合度，今后开发起别的项目起来会非常顺畅，这一点跟asp和php又很大不同，我不否认PHP的灵活，但是php在国内的开发者手里完全是面向过程的语言，成百上千个全局函数让我很不适应。JAVA项目的开发自始自终散发出一种面向对象和解藕的光辉，这是让我感到愉悦的。  
    Spring的核心思想是解藕，对象的初始化在xml中描述出来了，应用程序不再需要new出一个对象并对其进行各种初始化，而是从Spring容器中取出这些初始化好的对象。下面来配置Spring，使用myeclipse添加spring特性后会得到一个applicationContext.xml，Spring会读取这个配置文件初始化一些bean以供我们注入。我先贴出我修改过的applicationContext.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
    <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"
    	xmlns:content="http://www.springframework.org/schema/context"
    	xmlns:tx="http://www.springframework.org/schema/tx"
    	xmlns:aop="http://www.springframework.org/schema/aop"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans
    		http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    		http://www.springframework.org/schema/context 
    		http://www.springframework.org/schema/context/spring-context-3.0.xsd
    		http://www.springframework.org/schema/tx 
    		http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
    		http://www.springframework.org/schema/aop 
    		http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">
    	
    	
    	<content:annotation-config/>
    	<content:component-scan base-package="com.flyding.jpress"/>
    	
    	
    	<bean id="placeHolder" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    		<property name="location">
    			<value>classpath:config.properties</value>
    		</property>
    	</bean>
    	
    	
    	<bean id="dataSource"  class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">  
            <property name="driverClass" value="${jdbc.driver}" />
    		<property name="jdbcUrl" value="${jdbc.url}" />
    		<property name="user" value="${jdbc.username}" />
    		<property name="password" value="${jdbc.psw}" />
    		<property name="initialPoolSize"><value>${hibernate.c3p0.initialPoolSize}</value></property>
    		<property name="minPoolSize"><value>${hibernate.c3p0.minPoolSize}</value></property>
    		<property name="maxPoolSize"><value>${hibernate.c3p0.maxPoolSize}</value></property>
    		<property name="maxIdleTime"><value>${hibernate.c3p0.timeout}</value></property>
    		<property name="maxStatements"><value>${hibernate.c3p0.max_statement}</value></property>
    		<property name="acquireIncrement"><value>${hibernate.c3p0.acquireIncrement}</value></property>
        </bean>  
    	
    	
    	<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
    		<property name="dataSource" ref="dataSource"/>
    		<property name="hibernateProperties">  
                <props>
    				<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
    				<prop key="hibernate.show_sql">true</prop>
    				<prop key="javax.persistence.validation.mode">none</prop>  
    			</props>
            </property>  
    		<property name="packagesToScan">  
                <value>com.flyding.jpress.model</value>  
            </property>  
    	</bean>
    	
    	
    	<bean	id="txManager"
    				class="org.springframework.orm.hibernate4.HibernateTransactionManager">
    		<property name="sessionFactory" ref="sessionFactory" />
    	</bean>
    	
    	
    	<aop:config>
    		
    		<aop:pointcut id="daoTransactionPt" expression="execution(public * com.flyding.jpress.dao.impl.*.*(..))"/>
    		
    		<aop:advisor pointcut-ref="daoTransactionPt" advice-ref="daoTransactionAdvice"/>	
    	</aop:config>
    	
    	
    	<tx:advice id="daoTransactionAdvice" transaction-manager="txManager">
    		<tx:attributes>
    			<tx:method name="get*" read-only="true"/>
    			<tx:method name="*" propagation="REQUIRED"/>
    		</tx:attributes>
    	</tx:advice>
    	
    	
    	<tx:annotation-driven transaction-manager="txManager"/>
    </beans>

这份配置文件是我从上一个项目中copy过来的，复用率非常高，稍作修改就能在新的项目中使用。基于SSH的开发流程非常清晰，不会让人无从下手，从Spring的配置文件开始，我们就已经看到是Spring在集成Hibernate了。将经常需要修改的数据源信息分离在独立的config.properties文件中，使用placeHolder占位符读取配置信息并将其填入。下面是一份config.properties文件：

jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/jpress
    jdbc.username=root
    jdbc.psw=********
    
    hibernate.dialect=org.hibernate.dialect.MySQLDialect
    hibernate.show_sql=true;
    hibernate.c3p0.initialPoolSize=10
    hibernate.c3p0.minPoolSize=10
    hibernate.c3p0.maxPoolSize=50
    hibernate.c3p0.timeout=300
    hibernate.c3p0.max_statement=50
    hibernate.c3p0.acquireIncrement=5

接下来需要着手编写Hibernate的model了，我习惯于使用annotation配置ORM映射关系，数据库中一共有10张表，其中有两个表是多对多的中间表，这两表是不产生模型的。所以我们一共需要生成8个java文件，并在文件中使用注解的方式描述类与数据库表的关系，myeclipse为我们提供了直接生成的工具，下面是一份由myeclipse生成的model：

package com.flyding.jpress.model;
    
    import java.sql.Timestamp;
    import java.util.HashSet;
    import java.util.Set;
    import javax.persistence.CascadeType;
    import javax.persistence.Column;
    import javax.persistence.Entity;
    import javax.persistence.FetchType;
    import javax.persistence.GeneratedValue;
    import javax.persistence.Id;
    import javax.persistence.OneToMany;
    import javax.persistence.Table;
    
    /**
     * User entity. @author flyding.com
     */
    @Entity
    @Table(name = "jp_user", catalog = "jpress")
    public class User implements java.io.Serializable {
    	private static final long serialVersionUID = 9010981240846378504L;
    	// Fields
    	private Long id;
    	private String username;
    	private String nickname;
    	private String password;
    	private String email;
    	private Timestamp registerDt;
    	private String userUrl;
    	private Integer userLevel;
    	private Set<Entry> entries = new HashSet<Entry>(0);
    	private Set<UserMeta> userMetas = new HashSet<UserMeta>(0);
    
    	// Constructors
    
    	/** default constructor */
    	public User() {
    	}
    
    	/** minimal constructor */
    	public User(String username, String password, String email,
    			Timestamp registerDt, Integer userLevel) {
    		this.username = username;
    		this.password = password;
    		this.email = email;
    		this.registerDt = registerDt;
    		this.userLevel = userLevel;
    	}
    
    	/** full constructor */
    	public User(String username, String nickname, String password,
    			String email, Timestamp registerDt, String userUrl,
    			Integer userLevel, Set<Entry> entries, Set<UserMeta> userMetas) {
    		this.username = username;
    		this.nickname = nickname;
    		this.password = password;
    		this.email = email;
    		this.registerDt = registerDt;
    		this.userUrl = userUrl;
    		this.userLevel = userLevel;
    		this.entries = entries;
    		this.userMetas = userMetas;
    	}
    
    	// Property accessors
    	@Id
    	@GeneratedValue
    	@Column(name = "id", unique = true, nullable = false)
    	public Long getId() {
    		return this.id;
    	}
    
    	public void setId(Long id) {
    		this.id = id;
    	}
    
    	@Column(name = "username", nullable = false, length = 50)
    	public String getUsername() {
    		return this.username;
    	}
    
    	public void setUsername(String username) {
    		this.username = username;
    	}
    
    	@Column(name = "nickname", length = 50)
    	public String getNickname() {
    		return this.nickname;
    	}
    
    	public void setNickname(String nickname) {
    		this.nickname = nickname;
    	}
    
    	@Column(name = "password", nullable = false, length = 50)
    	public String getPassword() {
    		return this.password;
    	}
    
    	public void setPassword(String password) {
    		this.password = password;
    	}
    
    	@Column(name = "email", nullable = false, length = 50)
    	public String getEmail() {
    		return this.email;
    	}
    
    	public void setEmail(String email) {
    		this.email = email;
    	}
    
    	@Column(name = "register_dt", nullable = false, length = 19)
    	public Timestamp getRegisterDt() {
    		return this.registerDt;
    	}
    
    	public void setRegisterDt(Timestamp registerDt) {
    		this.registerDt = registerDt;
    	}
    
    	@Column(name = "user_url", length = 50)
    	public String getUserUrl() {
    		return this.userUrl;
    	}
    
    	public void setUserUrl(String userUrl) {
    		this.userUrl = userUrl;
    	}
    
    	@Column(name = "user_level", nullable = false)
    	public Integer getUserLevel() {
    		return this.userLevel;
    	}
    
    	public void setUserLevel(Integer userLevel) {
    		this.userLevel = userLevel;
    	}
    
    	@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "user")
    	public Set<Entry> getEntries() {
    		return this.entries;
    	}
    
    	public void setEntries(Set<Entry> entries) {
    		this.entries = entries;
    	}
    
    	@OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, mappedBy = "user")
    	public Set<UserMeta> getUserMetas() {
    		return this.userMetas;
    	}
    
    	public void setUserMetas(Set<UserMeta> userMetas) {
    		this.userMetas = userMetas;
    	}
    }

生成8个类似的数据层model后，我们的项目工程如图所示：  
![original_eztj_7bfe00001fd3125c.jpg][]  
    今天先写到这里，下一章我们将来设计数据库接口，原则上的构架是：一个数据库model会对应一个DAO，并有一个Impl类来实现这个接口，将这个Impl使用Spring的annotation注解为componet供将来的业务层注入使用。实际操作过程中，我们会首先设计一个通用接口BaseDao，在通用接口中使用JAVA泛型定义一组重用率非常高的增删改查操作，我们会有一个通用接口的通用抽象实现BaseDaoImpl，各个DAO接口继承自这个通用数据接口BaseDao，各个DAO的Impl继承自BaseDaoImpl并实现各自的接口，这样说上去比较绕，下一章实际操作起来其实层次感非常清晰。

转载于:https://www.cnblogs.com/newflypig/archive/2012/03/16/2861988.html

[original_eztj_7bfe00001fd3125c.jpg]: http://fmn.rrimg.com/fmn059/20120316/1825/original_eztj_7bfe00001fd3125c.jpg