2，从零开始搭建SSHM开发框架（集成Spring+JPA）

1.修改pom.xml


    4.0.0
    com.wiker
    sshm
    war
    1.0-SNAPSHOT
    sshm Maven Webapp
    http://maven.apache.org
    
    
        5.1.0.Final
        4.2.5.RELEASE
        1.2.17

        UTF-8
        1.8
    
    

        
        
            org.hibernate
            hibernate-core
            ${hibernate-version}
        
        
            org.hibernate
            hibernate-entitymanager
            ${hibernate-version}
        
        
        
        
            mysql
            mysql-connector-java
            5.1.38
        

        
        
            org.springframework
            spring-context
            ${spring-version}
        
        
            org.springframework
            spring-aop
            ${spring-version}
        
        
            org.springframework
            spring-context-support
            ${spring-version}
        
        
            org.springframework
            spring-jdbc
            ${spring-version}
        
        
            org.springframework.data
            spring-data-jpa
            1.9.4.RELEASE
        
        
            org.springframework
            spring-orm
            ${spring-version}
        
        
            org.springframework
            spring-web
            ${spring-version}
        
        
        
            com.alibaba
            druid
            1.0.22
        
        
            log4j
            log4j
            ${log4j-version}
        
        
        
        
            org.springframework
            spring-test
            ${spring-version}
            test
        
        
            junit
            junit
            4.11
            test
        
    
    
        sshm

2.增加applicationContext-service.xml




    Spring Service Configration

    
    
    
    
    


    
        
            
                classpath:application.properties
            
        
    
    
    
    
    
        
        
        
        
            
                
            
        
        
            
                
                3
                18
                10
                
                org.hibernate.cfg.DefaultNamingStrategy
                ${generateDdl}
                
                
                
                ${showSql}
                
                ${format_sql}
                
                org.hibernate.cache.NoCacheProvider
                
                none

3.增加application.properties配置文件

#mysql database setting
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=false
jdbc.username=root
jdbc.password=root
jdbc.maxActive=2000
jdbc.initialSize=50
jdbc.maxWait=60000
jdbc.minIdle=50
jdbc.timeBetweenEvictionRunsMillis=3000
jdbc.minEvictableIdleTimeMillis=300000
showSql=true
format_sql = true
#validate               加载hibernate时，验证创建数据库表结构
#create                  每次加载hibernate，重新创建数据库表结构，这就是导致数据库表数据丢失的原因。
#create-drop        加载hibernate时创建，退出是删除表结构
#update                 加载hibernate自动更新数据库结构
#none   不更新表结构
generateDdl=update

4.增加log4j.properties配置

###############################log4j.properties###############################
##### Global Log Level(OFF,FATAL,ERROR,WARN,INFO,DEBUG,ALL) #############
#log4j.rootLogger=info,stdout,info,debug,error
log4j.rootLogger=ALL,STDOUT,FILELOGER

###### STDOUT Logger ###############
log4j.appender.STDOUT=org.apache.log4j.ConsoleAppender
log4j.appender.STDOUT.Threshold=DEBUG
log4j.appender.STDOUT.layout=org.apache.log4j.PatternLayout
log4j.appender.STDOUT.layout.ConversionPattern=[%d{yyy-MM-dd HH:mm:ss.SSS}] [%p] - [%m]%n

5.修改web.xml





    
        javax.servlet.jsp.jstl.fmt.localizationContext
        messages
    
    
        contextConfigLocation
        
            classpath:/applicationContext-service.xml
        
    
    
        spring.profiles.default
        production
    
    
    
        org.springframework.web.context.ContextLoaderListener
    
  Archetype Created Web Application

6.增加实体、DAO

TestEntity.java

package com.wiker.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "t_test",catalog = "test")
public class TestEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="id")
    private Long id;
    
    @Column(name="content")
    private String content;

    public Long getId() {
        return id;
    }

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

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }
    
    
}

TestDao.java

package com.wiker.repository;

import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
import org.springframework.data.repository.PagingAndSortingRepository;

import com.wiker.entity.TestEntity;

public interface TestDao extends PagingAndSortingRepository, 
    JpaSpecificationExecutor {

}

TestService.java

package com.wiker.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.wiker.entity.TestEntity;
import com.wiker.repository.TestDao;

@Service
@Transactional(readOnly = true)
public class TestService {

    @Autowired
    private TestDao testDao;
    
    @Transactional(readOnly=false)
    public TestEntity add(TestEntity t){
        return testDao.save(t);
    }
    
    public List getAll(){
        return (List) testDao.findAll();
    }
}

7.增加java测试类，新建的类放到src/test/java中

BaseProductionProfiles.java

package com.wiker.test;

import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * Created by wiker on 2016/3/21.
 */
@RunWith(SpringJUnit4ClassRunner.class)
//@PropertySource(name = AbstractEnvironment.DEFAULT_PROFILES_PROPERTY_NAME,value = "test")
@ActiveProfiles("production")
@ContextConfiguration(locations = { "classpath:applicationContext-service.xml"})
public class BaseProductionProfiles extends AbstractTransactionalJUnit4SpringContextTests {



    @Test
    @Ignore
    public void test(){}
}

JunitTestService.java

package com.wiker.test;
import java.util.List;

import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;

import com.wiker.entity.TestEntity;
import com.wiker.service.TestService;

/**
 * Created by wiker on 2016-06-22.
 */
public class JunitTestService extends BaseProductionProfiles {

    @Autowired
    private TestService testService;

    @Test
    public void testDao(){
        TestEntity test = new TestEntity();
        test.setContent("测试的内容");
        //插入数据
        testService.add(test);
        
        //查询数据
        List list = (List) testService.getAll();
        for(TestEntity t:list){
            System.out.println("Content:"+t.getContent());
        }
        
    }
}

8.Junit运行JunitTestService

可以去test数据库看，表应该生成了。测试的内容也打印了（细心的同学会发现，通过测试的数据貌似是不会真正的写到数据库，如果需要真正的写数据库可以在BaseProductionProfiles.java中使用@TransactionConfiguration注解）。如下图：

最后的项目结构

9.JPA一些其它的用法

And --- 等价于 SQL 中的 and 关键字，比如 findByUsernameAndPassword(String user, Striang pwd)；
Or --- 等价于 SQL 中的 or 关键字，比如 findByUsernameOrAddress(String user, String addr)；
Between --- 等价于 SQL 中的 between 关键字，比如 findBySalaryBetween(int ma- x, int min)；
LessThan --- 等价于 SQL 中的 "<"，比如 findBySalaryLessThan(int max)；
GreaterThan --- 等价于 SQL 中的">"，比如 findBySalaryGreaterThan(int min)；
IsNull --- 等价于 SQL 中的 "is null"，比如 findByUsernameIsNull()；
IsNotNull --- 等价于 SQL 中的 "is not null"，比如 findByUsernameIsNotNull()；
NotNull --- 与 IsNotNull 等价；
Like --- 等价于 SQL 中的 "like"，比如 findByUsernameLike(String user)；
NotLike --- 等价于 SQL 中的 "not like"，比如 findByUsernameNotLike(String user)；
OrderBy --- 等价于 SQL 中的 "order by"，比如 findByUsernameOrderBySalaryAsc(String user)；
Not --- 等价于 SQL 中的 "！ ="，比如 findByUsernameNot(String user)；
In --- 等价于 SQL 中的 "in"，比如 findByUsernameIn(Collection userList) ，方法的参数可以是 Collection 类型，也可以是数组或者不定长参数；
NotIn --- 等价于 SQL 中的 "not in"，比如 findByUsernameNotIn(Collection userList) ，方法的参数可以是 Collection 类型，也可以是数组或者不定长参数；

** 如果上面的也不能满足？没关系JPA也提供了使用JPQL的语句，比较类似HQL **

使用 @Query 提供自定义查询语句示例

 public interface UserDao extends Repository { 

     @Query("select a from AccountInfo a where a.accountId = ?1") 
     public AccountInfo findByAccountId(Long accountId); 

    @Query("select a from AccountInfo a where a.balance > ?1") 
     public Page findByBalanceGreaterThan( 
 Integer balance,Pageable pageable); 
 }

** 如果有update的呢，也没关系，使用@Modifying注解 **

@Modifying 
@Query("update AccountInfo a set a.salary = ?1 where a.salary < ?2") 
public int increaseSalary(int after, int before);

10.想分页查询怎么办？JPA也有强大的支持

可以看看我们写的DAO中有哪些方法：

JPA分页

看见findAll(Pageable arg0)这个方法没，通过传一个Pageable的参数就可以了。可以看到dao里面还有其它常用的方法，如排序。
还有findAll(Specification spec, Pageable pageable); Specification是什么，这里面可以封装一些查询条件。这里可以推荐一个开源的框架，springside。或者自己写也不难，如下图：

条件查询

看看我写的service，如图：