Spring 三种数据库连接方式、传统连接、JdbcTemplate、Spring Jpa data（下）

最新推荐文章于 2024-06-15 11:12:38 发布

冰怜

最新推荐文章于 2024-06-15 11:12:38 发布

阅读量1.9k

点赞数 2

分类专栏： springboot 文章标签： SpringJPA

本文链接：https://blog.csdn.net/xiaoxin0630/article/details/88252548

版权

springboot 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

我现在经常用到Spring JPA Data

和逆向工程一样方便

GitHub地址：https://github.com/binlian/binglian-Spring-JPA-Data

它有自己的定义规则，可以不用在写那些SQL语句了，

可以根据id name来查询两个一起查询等

public Employee findByName(String name);

这传代码就是根据name查询数据

Maven jar引入放入pom.xml

        <!--spring data jpa-->
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-jpa</artifactId>
            <version>1.8.0.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.hibernate</groupId>
            <artifactId>hibernate-entitymanager</artifactId>
            <version>4.3.6.Final</version>
        </dependency>

配置文件

bean-new.xml

其实这些配置都是一环扣一环的

<prop key="hibernate.show_sql">true</prop> 打印SQL语句
<prop key="hibernate.format_sql">true</prop> 这个是代码格式化

<?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:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:jpa="http://www.springframework.org/schema/data/jpa"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/data/jpa http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
		http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">

    <!--1 配置数据源-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
        <property name="url" value="jdbc:mysql://localhost:3306/jdbc"/>
    </bean>

    <!--2 配置EntityManagerFactory-->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"/>
        </property>
        <property name="packagesToScan" value="com.binglian"/>

        <property name="jpaProperties">
            <props>
                <prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>

    </bean>

    <!--3 配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>

    <!--4 配置支持注解的事务-->
    <tx:annotation-driven transaction-manager="transactionManager"/>

    <!--5 配置spring data-->
    <jpa:repositories base-package="com.binglian" entity-manager-factory-ref="entityManagerFactory"/>

    <context:component-scan base-package="com.binglian"/>

</beans>

然后看下代码

使用Jpa 需要继承Repository

也可以使用注解方式（添加注解能到达到不用extends Repository的功能）

@RepositoryDefinition(domainClass = Employee.class, idClass = Integer.class)

Repository类的定义：
public interface Repository<T, ID extends Serializable> {

}

Repository是一个空接口，标记接口
没有包含方法声明的接口

package com.binglian.repository;

import org.springframework.data.jpa.repository.Modifying;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;
import org.springframework.data.repository.RepositoryDefinition;
import org.springframework.data.repository.query.Param;

import com.binglian.domain.Employee;

import java.util.List;


@RepositoryDefinition(domainClass = Employee.class, idClass = Integer.class)
public interface EmployeeRepository { //extends Repository<Employee,Integer>{

    public Employee findByName(String name);

    // where name like ?% and age <?
    public List<Employee> findByNameStartingWithAndAgeLessThan(String name, Integer age);

    // where name like %? and age <?
    public List<Employee> findByNameEndingWithAndAgeLessThan(String name, Integer age);

    // where name in (?,?....) or age <?
    public List<Employee> findByNameInOrAgeLessThan(List<String> names, Integer age);

    // where name in (?,?....) and age <?
    public List<Employee> findByNameInAndAgeLessThan(List<String> names, Integer age);

    @Query("select o from Employee o where id=(select max(id) from Employee t1)")
    public Employee getEmployeeByMaxId();

    @Query("select o from Employee o where o.name=?1 and o.age=?2")
    public List<Employee> queryParams1(String name, Integer age);

    @Query("select o from Employee o where o.name=:name and o.age=:age")
    public List<Employee> queryParams2(@Param("name")String name, @Param("age")Integer age);

    @Query("select o from Employee o where o.name like %?1%")
    public List<Employee> queryLike1(String name);

    @Query("select o from Employee o where o.name like %:name%")
    public List<Employee> queryLike2(@Param("name")String name);

    @Query(nativeQuery = true, value = "select count(1) from employee")
    public long getCount();

    @Modifying
    @Query("update Employee o set o.age = :age where o.id = :id")
    public void update(@Param("id")Integer id, @Param("age")Integer age);



}

test类

package com.imooc.repository;


import org.hibernate.action.internal.EntityIncrementVersionProcess;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;

import com.binglian.domain.Employee;
import com.binglian.repository.EmployeeJpaRepository;
import com.binglian.repository.EmployeePagingAndSortingReposity;
import com.binglian.repository.EmployeeRepository;
import com.binglian.service.EmployeeService;

import java.util.ArrayList;
import java.util.List;

public class EmployeeJpaRepositoryTest {


    private ApplicationContext ctx = null;

    private EmployeeJpaRepository employeeJpaRepository=null;
    
    @Before
    public void setup() {
        ctx = new ClassPathXmlApplicationContext("beans-new.xml");
        employeeJpaRepository= ctx.getBean(EmployeeJpaRepository.class);
        System.out.println("setup");
    }

    @After
    public void tearDown() {
        ctx = null;
        System.out.println("tearDown");
    }

    
    
    @Test
    public void testFind(){
    	Employee employee=employeeJpaRepository.findOne(99);
    	
    	System.out.println("employee:"+employee);
    	
    	System.out.println("emloyee(10)"+employeeJpaRepository.exists(10));
    	System.out.println("emloyee(102)"+employeeJpaRepository.exists(102));
    }
   
}

更新删除需要@Modifying

也需要service 才可以成功运行

@Modifying
@Query("update Employee o set o.age = :age where o.id = :id")
public void update(@Param("id")Integer id, @Param("age")Integer age);

自动创建数据库根据实体类自动创建数据库

package com.binglian.domain;

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

/**
 * 雇员：先开发实体类====>自动生成数据表
 */
@Entity
@Table(name="test_employee")
public class Employee {

    private Integer id;

    private String name;

    private Integer age;

    @GeneratedValue
    @Id
    public Integer getId() {
        return id;
    }

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

    @Column(length = 20)
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

CrudReository

package com.binglian.repository;

import org.springframework.data.jpa.repository.JpaRepository;

import com.binglian.domain.Employee;

public interface EmployeeJpaRepository extends JpaRepository<Employee, Integer>{

}

test类

save使用

employeeService.save(employees);

package com.imooc.repository;


import org.hibernate.action.internal.EntityIncrementVersionProcess;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.binglian.domain.Employee;
import com.binglian.repository.EmployeeRepository;
import com.binglian.service.EmployeeService;

import java.util.ArrayList;
import java.util.List;

public class EmployeeCrudRepositoryTest {


    private ApplicationContext ctx = null;

    private EmployeeService employeeService=null;
    
    @Before
    public void setup() {
        ctx = new ClassPathXmlApplicationContext("beans-new.xml");
        employeeService= ctx.getBean(EmployeeService.class);
        System.out.println("setup");
    }

    @After
    public void tearDown() {
        ctx = null;
        System.out.println("tearDown");
    }

    
    @Test
    public void  testSave(){
    	
    	List<Employee> employees=new ArrayList<Employee>();
    	
    	Employee employee=null;
    	for(int i=0;i<100;i++){
    		employee=new Employee();
    		employee.setAge(100-i);
    		employee.setName("test"+i);
    		employees.add(employee);
    	}
    	
    	employeeService.save(employees);
    }
}

这个分页在工作也比较常用

分页、排序

package com.binglian.repository;

import org.springframework.data.repository.PagingAndSortingRepository;

import com.binglian.domain.Employee;

public interface EmployeePagingAndSortingReposity extends PagingAndSortingRepository<Employee, Integer>{

}

Test类

Sort.Direction.DESC,"id"根据id正序
Sort.Order order=new Sort.Order(Sort.Direction.DESC,"id");
Sort sort=new Sort(order);

//page：index是0开始的,不是从1开始的

Pageable pageable=new PageRequest(0, 5);

Page<Employee> page=employeePagingAndSortingReposity.findAll(pageable);

Page 封装了页数这些属性
System.out.println("查询的总页数"+page.getTotalPages());
System.out.println("查询的总记录数"+page.getTotalElements());

package com.imooc.repository;


import org.hibernate.action.internal.EntityIncrementVersionProcess;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;

import com.binglian.domain.Employee;
import com.binglian.repository.EmployeePagingAndSortingReposity;
import com.binglian.repository.EmployeeRepository;
import com.binglian.service.EmployeeService;

import java.util.ArrayList;
import java.util.List;

public class EmployeePagingSortingRepositoryTest {


    private ApplicationContext ctx = null;

    private EmployeePagingAndSortingReposity employeePagingAndSortingReposity=null;
    
    @Before
    public void setup() {
        ctx = new ClassPathXmlApplicationContext("beans-new.xml");
        employeePagingAndSortingReposity= ctx.getBean(EmployeePagingAndSortingReposity.class);
        System.out.println("setup");
    }

    @After
    public void tearDown() {
        ctx = null;
        System.out.println("tearDown");
    }

    
    
    @Test
    public void testPage(){
    	
    	//根据id正序排序
    	Sort.Order order=new Sort.Order(Sort.Direction.DESC,"id");
    	Sort sort=new Sort(order);
    	
    	//page：index是0开始的,不是从1开始的
    	Pageable pageable=new PageRequest(0, 5);
    	Page<Employee> page=employeePagingAndSortingReposity.findAll(pageable);
    
    	System.out.println("查询的总页数"+page.getTotalPages());
    	System.out.println("查询的总记录数"+page.getTotalElements());
    	System.out.println("查询的当前第几页"+page.getNumber());
    	System.out.println("查询的当前页面的集合"+page.getContent());
    	System.out.println("查询的当前页面的记录数"+page.getNumberOfElements());
    	
    }
   
}

JpaRepository

package com.binglian.repository;

import org.springframework.data.jpa.repository.JpaRepository;

import com.binglian.domain.Employee;

public interface EmployeeJpaRepository extends JpaRepository<Employee, Integer>{

}

JpaSpecificationRepository

这个是多继承可以使用两个方法

package com.binglian.repository;

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

import com.binglian.domain.Employee;

/**
 * 也是可以多继承
 * @author binglian
 *
 */
public interface EmployeeJpaSpecificationExecutorRepository 
		extends JpaRepository<Employee, Integer>,JpaSpecificationExecutor<Employee>{

}

/**
    	 * root:就是我们要查询的类型(Employee)
    	 * query:添加查询天剑
    	 * cb:构建Predicate
    	 */
    	Specification<Employee> specification=new Specification<Employee>() {

			@Override
			public Predicate toPredicate(Root<Employee> root,
						CriteriaQuery<?> query, 
						CriteriaBuilder cb) {

				Path path=root.get("age");
				
				
				return cb.gt(path, 50);//age大于20;
			}
		
    	};
    	
    	Page<Employee> page=employeeJpaSpecificationExecutorRepository.findAll(specification,pageable);

package com.imooc.repository;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Path;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.jpa.domain.Specification;

import com.binglian.domain.Employee;
import com.binglian.repository.EmployeeJpaRepository;
import com.binglian.repository.EmployeeJpaSpecificationExecutorRepository;

public class EmployeeJpaSpecificationExecutorRepositoryTest {

	private ApplicationContext ctx = null;

    private EmployeeJpaSpecificationExecutorRepository employeeJpaSpecificationExecutorRepository=null;
    
    @Before
    public void setup() {
        ctx = new ClassPathXmlApplicationContext("beans-new.xml");
        employeeJpaSpecificationExecutorRepository= ctx.getBean(EmployeeJpaSpecificationExecutorRepository.class);
        System.out.println("setup");
    }

    @After
    public void tearDown() {
        ctx = null;
        System.out.println("tearDown");
    }

    
    /**
     * 分页
     * 排序
     * 查询条件
     */
    @Test
    public void testQuery(){
    	//根据id正序排序
    	Sort.Order order=new Sort.Order(Sort.Direction.DESC,"id");
    	Sort sort=new Sort(order);
    
    	
    	
    	//page：index是0开始的,不是从1开始的
    	Pageable pageable=new PageRequest(0, 5);
    	
    	
    	/**
    	 * root:就是我们要查询的类型(Employee)
    	 * query:添加查询天剑
    	 * cb:构建Predicate
    	 */
    	Specification<Employee> specification=new Specification<Employee>() {

			@Override
			public Predicate toPredicate(Root<Employee> root,
						CriteriaQuery<?> query, 
						CriteriaBuilder cb) {

				Path path=root.get("age");
				
				
				return cb.gt(path, 50);//age大于20;
			}
		
    	};
    	
    	Page<Employee> page=employeeJpaSpecificationExecutorRepository.findAll(specification,pageable);
    	
//    	Page<Employee> page=employeeJpaSpecificationExecutorRepository.findAll(pageable);
    
    	System.out.println("查询的总页数"+page.getTotalPages());
    	System.out.println("查询的总记录数"+page.getTotalElements());
    	System.out.println("查询的当前第几页"+page.getNumber());
    	System.out.println("查询的当前页面的集合"+page.getContent());
    	System.out.println("查询的当前页面的记录数"+page.getNumberOfElements());
    	
    }
}

冰怜

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Spring 三种数据库连接方式、传统连接、JdbcTemplate、Spring Jpa data（下）

我现在经常用到Spring JPA Data和逆向工程一样方便GitHub地址：https://github.com/binlian/binglian-Spring-JPA-Data它有自己的定义规则，可以不用在写那些SQL语句了，可以根据id name来查询两个一起查询等public Employee findByName(String name);这传代码就是 ...
复制链接

扫一扫

专栏目录