有时候在项目中,我们并不是每个项目都是 Web 项目,我们也许只是对接一下接口或者单纯的操作一下数据库而已,但是如果直接使用 Jdbc 进行又比较麻烦,这时候就比较怀念使用 Spring 进行 Web 开发的日子,操作数据库不能更简单了.还要 Spring 的项目基本都可以单独拿来使用,这样我们就不必为了一个简单的数据操作引入一些不必要的东西,Spring data jpa 就刚好满足了操作数据库的需求,而且 Jpa 可以为我们的程序带来很好的移植性,访问不同的数据库仅仅是需要修改一下数据连接就可以完善搞定.下面我们就以 Mysql 为例,对一个 User 对象进行操作.

1. 引入依赖

  惯例,使用别人的东西,当然得引入别人的包,为了使用 Spring data jpa,我们首先引入Spring Framework,然后再引入Spring data jpa,当然了,使用MySql数据库,我们了得引入它的数据库连接.除此之外还得引入一些其它东西,比如Hibernate这样的 Orm 框架,还有一些日志相关的东西,些片省略...

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <spring.version>4.3.5.RELEASE</spring.version>
    <spring-data-jpa.version>1.11.1.RELEASE</spring-data-jpa.version>
    <spring-data-commons-core.version>1.4.1.RELEASE</spring-data-commons-core.version>
    <hibernate.version>5.2.9.Final</hibernate.version>
    <mysql.conn.version>5.1.27</mysql.conn.version>
</properties>

<dependencies>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-context -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-core -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-jpa -->
    <dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-jpa</artifactId>
        <version>${spring-data-jpa.version}</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.hibernate/hibernate-core -->
    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>${hibernate.version}</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql.conn.version}</version>
    </dependency>
</dependencies>

特别注意的地方需要说明一下:

• 引入Hibernate框架的时候,只引入核心版本就可以了,不用引入Hibernaet entitymanager,因为高版本的 core 带了 entitymanager,而且 Maven 仓库里面已经标记 entitymanager 过时了;
• 引入 Spring 的时候,需要引入 4.3.X 及其以上的版本,不然运行的时候会报错,其中的类 MethodClassKey.java 找不到,因为该类是 4.3 以后才引入的.

2. 创建实体

实体就是一个单独的 User,实现对它CRUD操作就 Okay了.

@Entity
@Table
public class User implements Serializable {
    
    private static final long serialVersionUID = -2407677666514147913L;

    @Id
    @GeneratedValue
    private Long id;

    @Column(unique = true)
    private String userName;
    
    private String password;
}

上面就是一个很简单的实体对象了,它实现了序例化接口,仅拥有三个属性,而其中一个还是主键.

3. 创建Respository对象

  因为我们使用的是 Spring data jpa,它给我们提供了一系列的操作,我们实现它的接口,并按它的规则定义接口里面的方法就可以实现数据库的CRUD操作.

@Repository
public interface UserRep extends JpaRepository<User, Long>{
    
    public User findByUserName(String userName);
}
// 不能更简单

4. 数据库配置

  为了示例的简单,我们跳过逻辑业务层的定义,直接配置数据库相关的操作,运行程序的时候操作调用 Repository 操作数据库.标准的 Jpa 需要在 classpath 路径下面配置 META-INF/persistence.xml 文件,在里面写 orm 和 数据源,用户名,密码等.当然我们采用 zero confgi ,这些东西,通通都不要了,只需要创建一个类,把它指定为配置文件就 OK 了.

@Configuration
@EnableTransactionManagement
public class PersistenceJPAConfig {

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
        LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(dataSource());
        // 把 package names 修改为你的 User 类所在的包名就可以了
        em.setPackagesToScan(new String[]{"package names"});
        JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
        em.setJpaVendorAdapter(vendorAdapter);
        em.setJpaProperties(additionalProperties());
        return em;
    }
    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/数据库名");
        dataSource.setUsername("用户名");
        dataSource.setPassword("密码");
        return dataSource;
    }
    @Bean
    public PlatformTransactionManager transactionManager(
            EntityManagerFactory emf) {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(emf);
        return transactionManager;
    }
    @Bean
    public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
        return new PersistenceExceptionTranslationPostProcessor();
    }

    Properties additionalProperties() {
        Properties properties = new Properties();
        properties.setProperty("hibernate.hbm2ddl.auto", "create-drop");
        properties.setProperty("hibernate.dialect",
                "org.hibernate.dialect.MySQL5Dialect");
        return properties;
    }
}

为什么要有这个文件,因为 <b>Spring data jpa</b> 就是这样规定的,关键点在于返回的那个 <b>transactionManager</b>,它就是 <b>Jpa</b>操作数据库的东西,也就是 <b>entitymanager</b>,所以才有了这个配置文件,以及里面的一些附加的东西,不然程序怎么知道你的数据以及密码呢?

5. Spring配置

上面的数据库相关的配置完成了,那是不是就应该启动程序测试一下了呢,那当然是可以了,但是我们用的是 <b>Spring</b> 的东西,我们还得告诉人家,那些类是做什么用的,比如那个是它的 <b>Spring data jpa</b>应该扫描的对象啊之类的东西,所以啊,就引出了下面这个 <b>Spring</b> 的 <b>Java Config</b>类.

@Configuration
@ComponentScan(basePackages = {"Spring需要扫描的包名"})
@EnableJpaRepositories(basePackages = {"定义的Jpa Respository所在的包位置"})
public class AppConfig {
    // ...
}

6. 启动项目

  到最最关键的一步了就是启动我们的项目了,大家都知道启动Spring项目得启动它的容器,因为我们是采用注解的方式进行的,所以我们启动的时候得用AnnotationConfigApplicationContext 这个类来启动.

@ComponentScan(basePackageClasses = {AppConfig.class,PersistenceJPAConfig.class})
public class App {
private static final Logger log = LoggerFactory.getLogger(App.class);

    public static void main(String[] args) {
        log.debug("Start spring ....");
        @SuppressWarnings("resource")
        ApplicationContext context = new AnnotationConfigApplicationContext(App.class);
        UserRep userRep = context.getBean(UserRep.class);
        User user = new User();
        user.setUserName("UserName");
        user.setPassword("password");
        System.out.println(userRep.save(user).getId());
    }
}

如此整个工作就算完成了,但是这儿跨层级调用.我们应该把对数据库的操作交给业务层来做,顶层只负责请求处理以及调用就可以了.对 Sprig zero cofig 配置以以及其中的日志等问题不了解的可以能看 Spring 零配置并解决Log日志

7. 总结

因为本例以最简单的方式来说明这个问题,其中有的地方比较精简,详细内容我已经放在 GitHub,大家可以 <b>Git</b> 下来看,写得不好的地方还请多多指点.