SpringBoot整合JPA单表crud操作

创建项目

左侧这边要的依赖可以在这先行导入, 不导入也可以, 还可通过pom.xml操作, 以下就是pom中导入依赖

导入依赖

		<!--spring-data-jpa-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>
        <!--druid连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.23</version>
        </dependency>
        <!--lombok; 需要lombok是因为简便-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

选择数据源

这一步要在application.yml里把druid的链接整好, 在这一步一定要注意层级, 因为层级关系很重要;

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/demo #数据库链接路径
    username: root		#数据库账号
    password: 123456	#数据库密码
    driver-class-name: com.mysql.cj.jdbc.Driver		#记得是中间带.cj的, 不带.cj的版本老了, 换新的了
    type: com.alibaba.druid.pool.DruidDataSource	#druid连接池
  jpa:
    hibernate:
      ddl-auto: update #自动更新
    show-sql: true  #日志中显示sql语句

那么到这一步如果都没问题的话就可以进行下一步写测试练习了;

练习

表信息

随便建一个表后期用

实体类

package com.yuntu.demo.entity;

import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import org.springframework.data.annotation.CreatedDate;

import javax.persistence.*;
import java.util.Date;

@Entity
@Table(name = "user")
@Data
public class UserForJpa {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    // difference: IDENTITY/AUTO
    // first one is concerned with database itself
    // second one is concerned with program
    // 那么在这的话 GenerationType的部分值当中选择IDENTITY/AUTO的区别是
    // 第一个是把主键策略交给数据库本身
    // 第二个则是交给程序控制
    @Column(name = "id")
    private Integer id;

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

    //Format the time
    //when concerned with date data, we need to make sure the nullable
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    // 对时间格式以及时区进行声明
    @Column(name = "birth", updatable = false, nullable = false)
    private Date birth;

    //created is only because this is the time when user first join in the club
    @CreatedDate
    // 创建时间
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
    @Column(name = "vip_date", updatable = false, nullable = false)
    private Date vip_date;

}

Repository

那么在这里面存放的则是指定的操作, 因为平常的修改和添加以及删除都是有写好的方法可以直接用;

package com.yuntu.demo.repository;

import com.yuntu.demo.entity.UserForJpa;
import org.apache.ibatis.annotations.Param;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;

public interface UserForJpaRepository extends JpaRepository<UserForJpa,Integer> {

    @Modifying
    @Query(value = "update UserForJpa set name= :name where id= :id",nativeQuery = false)
//    @Query(value = "update user set name=? where id=?",nativeQuery = true)
    int modifySingleUserById(@Param("name")String name,@Param("id")Integer id);
}

Service

package com.yuntu.demo.service;

import com.yuntu.demo.entity.UserForJpa;

import java.util.List;

public interface UserService {

    UserForJpa insertion(UserForJpa user);


    /**
     * query single user by using only id
     * @param id only id
     * @return a user data
     */
    UserForJpa queryUserById(Integer id);

    /**
     * query all the user exists in table
     * @return all user data inside a list
     */
    List<UserForJpa> queryAllUser();

    /**
     * delete user info by id
     * @param id only id
     */
    void deleteUser(Integer id);

    /**
     * modify single user through user class itself
     * @param user user class
     * @return a user data
     */
    UserForJpa modifySingleUser(UserForJpa user);

    /**
     * modify single user through user's id
     * @param id only id
     * @return Integer for later
     */
    int modifySingleUserById(String name,Integer id);

}

实现Service

package com.yuntu.demo.service.impl;

import com.yuntu.demo.entity.UserForJpa;
import com.yuntu.demo.repository.UserForJpaRepository;
import com.yuntu.demo.service.UserService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.transaction.Transactional;
import java.util.List;

@Service
public class UserServiceImpl implements UserService {

    @Resource
    private UserForJpaRepository userRepository;


    @Override
    public UserForJpa insertion(UserForJpa user) {
        return userRepository.save(user);
    }

    @Override
    public UserForJpa queryUserById(Integer id) {
        return userRepository.findById(id).orElse(null);
    }

    @Override
    public List<UserForJpa> queryAllUser() {
        return userRepository.findAll();
    }

    @Override
    public void deleteUser(Integer id) {
        userRepository.deleteById(id);
    }

    @Override
    public UserForJpa modifySingleUser(UserForJpa user) {
        return userRepository.save(user);
    }

    @Override
    @Transactional
    public int modifySingleUserById(String name,Integer id) {
        return userRepository.modifySingleUserById(name,id);
    }
}

启动类

package com.yuntu.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;

@EnableJpaAuditing
@SpringBootApplication
public class UserStarterApplication {
    public static void main(String[] args) {
        SpringApplication.run(UserStarterApplication.class,args);
    }
}

测试类

package com.yuntu.demo;

import com.yuntu.demo.entity.UserForJpa;
import com.yuntu.demo.service.impl.UserServiceImpl;
import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;
import java.util.*;

@SpringBootTest
public class UserStarterApplicationTest {
    @Resource
    private UserServiceImpl userService;

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    Date date = new Date();

    @Test
    void insertion() throws ParseException {
        UserForJpa user = new UserForJpa();
        user.setName("insertTest");
        user.setBirth(sdf.parse(sdf.format(date)));
        user.setVip_date(sdf.parse(sdf.format(date)));
        UserForJpa returns = userService.insertion(user);
        System.out.println(returns);
    }

    @Test
    void modify() {
        UserForJpa userInfo = userService.queryUserById(11);
        UserForJpa user = new UserForJpa();
        user.setId(11);
        user.setName("modifyTest");
        user.setBirth(userInfo.getBirth());
        user.setVip_date(userInfo.getVip_date());
        UserForJpa returns = userService.modifySingleUser(user);
        System.out.println(returns);
    }

    @Test
    void query() {
        List<UserForJpa> user = userService.queryAllUser();
        for (UserForJpa list : user) {
            System.out.println(list);
        }
    }
}

第一步测试

目前这些是我表内的数据
执行insertion测试(添加操作)

那么可以看到在这一步的话, 添加是成功的

第二步测试

所以还是成功了的

第三步测试

那么也是成功的找到了所有的数据;
以上呢就是整合JPA后要对于单表进行的简单增删改, 应该还是属于比较简单的, 有运行异常等情况都可以联系我;