springboot-jpa操作数据库

    JPA全称Java Persistence API.JPA通过JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。
　　JPA包括以下3方面的技术：
　　1.ORM映射元数据。JPA支持XML和JDK5.0注解两种元数据的形式，元数据描述对象和表之间的映射关系，框架据此将实体对象持久化到数据库表中；
　　2.API。用来操作实体对象，执行CRUD操作，框架在后台替我们完成所有的事情，开发者从繁琐的JDBC和SQL代码中解脱出来。
　　3.查询语言。这是持久化操作中很重要的一个方面，通过面向对象而非面向数据库的查询语言查询数据，避免程序的SQL语句紧密耦合。

　　由于JPA框架中支持大数据集、事务、并发等容器级事务，这使得 JPA 超越了简单持久化框架的局限，在企业应用发挥更大的作用.

    SpringData JPA 框架，主要针对的就是 Spring 唯一没有简化到的业务逻辑代码，至此，开发者连仅剩的实现持久层业务逻辑的工作都省了，唯一要做的，就只是声明持久层的接口，其他都交给 Spring Data JPA 来帮你完成.

以下通过创建项目具体操作来一起了解项目。

创建项目

File->New->Project->New module,

创建完成后如下：

在pom.xml中配置数据库依赖包

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.example.springboot</groupId>
    <artifactId>springboot-jpa</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>springboot-jpa</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.7</java.version>
    </properties>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.12.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <!--jpa依赖包-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!--mysql连接-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
</project>

在application.properties配置文件中增加数据库连接，jpa连接

#修改server端口
#server.port=8085
#server.context-path=/springdemo

#mysql数据连接
spring.datasource.url=jdbc:mysql://localhost:3306/test
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driverClassName=com.mysql.jdbc.Driver
#spring.datasource.max-active=20
#spring.datasource.max-idle=8
#spring.datasource.min-idle=8
#spring.datasource.initial-size=20


#spirng jpa 配置
spring.jpa.database=MYSQL
#显示sql语句
spring.jpa.show-sql=false
spring.jpa.generate-ddl=true
# Hibernate ddl auto (create, create-drop, update)
spring.jpa.hibernate.ddl-auto=update
#spring.jpa.database-platform=org.hibernate.dialect.MySQL5Dialect  
spring.jpa.hibernate.naming_strategy=org.hibernate.cfg.ImprovedNamingStrategy  
#spring.jpa.database=org.hibernate.dialect.MySQL5InnoDBDialect 
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect

编写user实体类

package com.example.springboot.jpa.entity;
import javax.persistence.*;

/**
 * @desc 使用@Entity进行实体类持久化操作，jpa会检测到该主键是，会自动生成表结构
 * @Author wangsh
 * @date 2018/5/5 21:40
 * @return
 */
@Entity
@Table(name = "t_User")
public class User {
   /**
    * @Id指定主键id,@GeneratedValue指定主键生成策略为自增长
    */
   @Id
   @GeneratedValue(strategy = GenerationType.AUTO)
   private int id;

   @Column(name = "username")
   private String userName;

   @Column(name = "password")
   private String password;}

编写dao操作数据库类

Repository接口是spring data 的一个核心接口，它不提供任何方法，开发者需要在自己定义接口中声明的方法。

package com.example.springboot.jpa.dao;

import com.example.springboot.jpa.entity.User;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface UserRepository extends CrudRepository<User, Integer> {

}

package com.example.springboot.jpa.dao;

import com.example.springboot.jpa.entity.User;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;
import org.springframework.data.repository.query.Param;

public interface UserRepository2 extends Repository<User, Integer> {

   /**
    * 查询以get|find|read开头； 条件属性以首字母大写
    */
   public User findByUserName(String userName);

   /**
    * 通过jpa hql语句查询
    */
   @Query(value = "from User where userName=:cn")
   public User findByUserName2(@Param("cn") String userName);
}

编写service类

package com.example.springboot.jpa.service;

import com.example.springboot.jpa.dao.UserRepository;
import com.example.springboot.jpa.dao.UserRepository2;
import com.example.springboot.jpa.entity.User;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import javax.transaction.Transactional;

@Service
public class UserService {

   @Resource
   private UserRepository userRepository;
   @Resource
   private UserRepository2 userRepository2;

   // 保存
   @Transactional
   public void save(User user) {
      userRepository.save(user);
   }

   // 删除
   @Transactional
   public void delete(int id) {
      userRepository.delete(id);
   }

   // 查询
   public void getUser(int id) {
      userRepository.findOne(id);
   }

   // 根据名称查询
   public User findByUserName(String userName) {
      return userRepository2.findByUserName(userName);
   }

   // 根据名称查询
   public User findByUserName2(String userName) {
      return userRepository2.findByUserName2(userName);
   }

}

编写controller类

package com.example.springboot.jpa.controller;

import com.example.springboot.jpa.entity.User;
import com.example.springboot.jpa.service.UserService;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;

/**
 * @desc
 * @Author wangsh
 * @date 2018/5/5 21:37
 */
@RestController
@RequestMapping("/jpa")
public class JpaController {

   @Resource
   private UserService userService;


   @RequestMapping("/save")
   public void save() {
      User user = new User();
      user.setUserName("zhangsan");
      user.setPassword("123");

      userService.save(user);
   }

   @RequestMapping("/findByUserName")
   public User findByUserName(String userName) {
      User user = userService.findByUserName(userName);
      System.out.println(user);
      return user;
   }

   @RequestMapping("/findByUserName2")
   public User findByUserName2(String userName) {
      User user = userService.findByUserName2(userName);
      System.out.println(user);
      return user;
   }

}

编写启动服务类

package com.example.springboot.jpa;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.transaction.annotation.EnableTransactionManagement;

/**
 * @desc
 * @Author wangsh
 * @date 2018/5/5 22:01
 * @return
 */
@EnableTransactionManagement
@SpringBootApplication
public class SpringbootJpaApplication {

   public static void main(String[] args) {
      SpringApplication.run(SpringbootJpaApplication.class, args);
   }
}

启动服务测试

浏览器访问： http://localhost:8080//jpa/findByUserName2?userName=张三8376