Springdatajpa-day1

最新推荐文章于 2022-01-12 14:59:26 发布

#0080FF

最新推荐文章于 2022-01-12 14:59:26 发布

阅读量99

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/qq_43853427/article/details/101595927

版权

java 专栏收录该内容

15 篇文章 0 订阅

订阅专栏

配置applicationContext.xml文件

<?xml version="1.0" encoding="UTF-8"?>

<!-- 扫描service部分的包 -->
<context:component-scan base-package="cn.itsource.pss.service" />
<context:property-placeholder location="classpath:jdbc.properties" />

<!-- 配置连接池 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <!--连接数据4个属性 -->
    <property name="driverClassName" value="${jdbc.driverClassName}" />
    <property name="url" value="${jdbc.url}" />
    <property name="username" value="${jdbc.username}" />
    <property name="password" value="${jdbc.password}" />
    <!--maxActive: 最大连接数量 -->
    <property name="maxActive" value="150" />
    <!--minIdle: 最小空闲连接 -->
    <property name="minIdle" value="5" />
    <!--maxIdle: 最大空闲连接 -->
    <property name="maxIdle" value="20" />
    <!--initialSize: 初始化连接 -->
    <property name="initialSize" value="30" />
    <!-- 用来配置数据库断开后自动连接的 -->
    <!-- 连接被泄露时是否打印 -->
    <property name="logAbandoned" value="true" />
    <!--removeAbandoned: 是否自动回收超时连接 -->
    <property name="removeAbandoned" value="true" />
    <!--removeAbandonedTimeout: 超时时间(以秒数为单位) -->
    <property name="removeAbandonedTimeout" value="10" />
    <!--maxWait: 超时等待时间以毫秒为单位 1000等于60秒 -->
    <property name="maxWait" value="1000" />
    <!-- 在空闲连接回收器线程运行期间休眠的时间值,以毫秒为单位. -->
    <property name="timeBetweenEvictionRunsMillis" value="10000" />
    <!-- 在每次空闲连接回收器线程(如果有)运行时检查的连接数量 -->
    <property name="numTestsPerEvictionRun" value="10" />
    <!-- 1000 * 60 * 30 连接在池中保持空闲而不被空闲连接回收器线程 -->
    <property name="minEvictableIdleTimeMillis" value="10000" />
    <property name="validationQuery" value="SELECT NOW() FROM DUAL" />
</bean>

<!-- 集成hibernate的jpa功能 -->
<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <property name="dataSource" ref="dataSource" />
    <!--待扫描的实体类包，不再需要persistence.xml了 -->
    <property name="packagesToScan" value="cn.itsource.aisell.domain" />
    <!-- 3.配置JPA的实现 -->
    <!-- private JpaVendorAdapter jpaVendorAdapter; -->
    <property name="jpaVendorAdapter">
        <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
            <!-- org.springframework.orm.jpa.vendor.AbstractJpaVendorAdapter -->
            <!-- private boolean showSql = false;是否显示sql语句 -->
            <property name="showSql" value="true" />
            <!-- private boolean generateDdl = false;是否建表 -->
            <property name="generateDdl" value="false" />
            <!-- private String databasePlatform;原来方言 -->
            <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
        </bean>
    </property>
</bean>

<!-- Jpa 事务配置 -->
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
    <property name="entityManagerFactory" ref="entityManagerFactory" />
</bean>
<!-- 注解声明式事务管理 -->
<tx:annotation-driven />

<!-- Spring Data Jpa配置 ********************************************-->
<!-- base-package:扫描的包 dao层 -->
<jpa:repositories base-package="cn.itsource.pss.repository" transaction-manager-ref="transactionManager"
                  entity-manager-factory-ref="entityManagerFactory" />

准备一个父类domain（提取公共id，避免每次重复创id）

import javax.persistence.Id;
import javax.persistence.MappedSuperclass;

//不用保存到数据库
@MappedSuperclass
//抽取一个公共类，创建id字段，避免多次创建
public class BaseDomain {
@Id
@GeneratedValue
private Long id;

public Long getId() {
    return id;
}

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

}

子类继承（之后的管理者，菜单，员工各种属性直接写自己独有的字段+继承父类domain id属性）

@Entity
public class Employee extends BaseDomain {
private String username;

private String password;

private String email;

private Integer age;

public String getEmail() {
    return email;
}

public void setEmail(String email) {
    this.email = email;
}

public Integer getAge() {
    return age;
}

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

public String getUsername() {
    return username;
}

public void setUsername(String username) {
    this.username = username;
}

public String getPassword() {
    return password;
}

public void setPassword(String password) {
    this.password = password;
}

@Override
public String toString() {
    return "Employee{" +
            "username='" + username + '\'' +
            ", password='" + password + '\'' +
            ", email='" + email + '\'' +
            ", age=" + age +
            '}';
}

SpringDataJpa:

它是JPA规范的再次封装抽象,底层还是使用了Hibernate的JPA技术实现，引用JPQL的查询语句，是属于Spring的生成体系中的一部分。减少开发的工作量，大大提高了开发效率

JpaRepository的CRUD

package cn.itsource.aisell;


import cn.itsource.aisell.domain.Employee;
import cn.itsource.aisell.repository.EmployeeRepository;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
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.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

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

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class TestSpringdataJpa {

    @Autowired
    private EmployeeRepository employeeRepository;

    //查询所有
    @Test
    public void testfindAll()throws Exception{
        for (Employee employee : employeeRepository.findAll()) {
            System.out.println(employee);

        }
    }
    //保存
    @Test
    public void testSave()throws Exception{
        Employee employee = new Employee();
        employee.setUsername("玉帝");
        employee.setPassword("123");
        employee.setAge(9999);

        employeeRepository.save(employee);
    }
    //修改
    @Test
    public void testName()throws Exception{
        Employee employee = new Employee();
        employee.setId(274L);
        employee.setUsername("玉皇大帝");
        employee.setEmail("scy@qq.com");

        employeeRepository.save(employee);
    }

    //删除
    @Test
    public void testdelete()throws Exception{
        employeeRepository.delete(274L);
    }

    //删除多条
    @Test
    public void testdelete2()throws Exception{
        List<Employee> list = new ArrayList<>();
        Employee employee = new Employee();
        employee.setId(275L);
        Employee employee1 = new Employee();
        employee1.setId(273L);
        list.add(employee);
        list.add(employee1);

        employeeRepository.deleteInBatch(list);

    }
    //查询表里面总的记录数
    @Test
    public void testConut()throws Exception{
        long count = employeeRepository.count();
        System.out.println(count);

    }

    //分页
    @Test
    public void testPage()throws Exception{
        Pageable pageable = new PageRequest(1, 10);
        Page<Employee> page = employeeRepository.findAll(pageable);
        //总条数
        long totalElements = page.getTotalElements();
        System.out.println(totalElements);

        //总共的页数
        int totalPages = page.getTotalPages();
        System.out.println(totalPages);

        //每页的数据,一共10条
        List<Employee> content = page.getContent();
        for (Employee employee : content) {
            System.out.println(employee);
        }

        //当前页
        int number = page.getNumber();
        System.out.println(number);

        //每页多少条数据
        int numberOfElements = page.getNumberOfElements();
        System.out.println(numberOfElements);
    }

    //排序 按照 age 升序或降序排序
    @Test
    public void testSort()throws Exception{
        //按照年龄升序排序
        Sort sort = new Sort(Sort.Direction.ASC,"age");
        List<Employee> list = employeeRepository.findAll(sort);
        for (Employee employee : list) {
            System.out.println(employee);
        }
    }
    //分页和排序 结合起来使用
    @Test
    public void testPageAndSort()throws Exception{
        Sort sort = new Sort(Sort.Direction.ASC,"age");
        Pageable pageable = new PageRequest(0, 10,sort);
        Page<Employee> page = employeeRepository.findAll(pageable);
        List<Employee> content = page.getContent();
        for (Employee employee : content) {
            System.out.println(employee);
        }

    }
    //按照条件规则查询 适合简单sql 或者条件比较少的sql
    @Test
    public void testfindByUsernameLike()throws Exception{
        List<Employee> byUsernameLike = employeeRepository.findByUsernameLike("%s%");
        for (Employee employee : byUsernameLike) {
            System.out.println(employee);

        }
    }
    //查询指定的名称
    @Test
    public void testName1()throws Exception{
        List<Employee> list = employeeRepository.findByUsername("玉帝");
        for (Employee employee : list) {
            System.out.println(employee);
        }
    }
    //年龄小于<20
    @Test
    public void testName2()throws Exception{
        List<Employee> list = employeeRepository.findByAgeLessThan(20);
        for (Employee employee : list) {
            System.out.println(employee);
        }
    }
    //注解查询
    @Test
    public void testName3()throws Exception{
        Employee employee = employeeRepository.queryEmployee();
        System.out.println(employee);
    }
    //根据员工用户名和密码模糊查询
    @Test
    public void testName4()throws Exception{
        List<Employee> list = employeeRepository.queryEmployee1("%玉%", "%1%");
        for (Employee employee : list) {
            System.out.println(list);
        }
    }
    //根据员工用户名和年龄具体查询
    @Test
    public void testName5()throws Exception{
        List<Employee> list = employeeRepository.queryEmployee2("admin", 34);
        for (Employee employee : list) {
            System.out.println(employee);

        }
    }
    //查询员工的平均年龄
    @Test
    public void testName6()throws Exception{
        Integer integer = employeeRepository.queryEmployee3();
        System.out.println(integer);

    }
}

规则查询

package cn.itsource.aisell.repository;

import cn.itsource.aisell.domain.Employee;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

import java.util.List;

public interface EmployeeRepository extends JpaRepository<Employee,Long> {
    //模糊查询
    public List<Employee> findByUsernameLike(String username);
    //根据名称查询
    public List<Employee> findByUsername(String username);
    //age小于
    public List<Employee> findByAgeLessThan(Integer age);

    //注解查询
    @Query("select o from Employee o where o.age = (select min(p.age) from Employee p)")
    public Employee queryEmployee();

    //根据员工用户名和密码模糊查询
    @Query("select o from Employee o where o.username like ?1 and o.password like ?2")
    public List<Employee> queryEmployee1(String username,String password);

    //根据员工用户名和年龄具体查询
    @Query("select o from Employee o where o.username like :username and o.age like :age")
    public List<Employee> queryEmployee2(@Param("username") String username,@Param("age") Integer age);

    //原生sql的支持
    @Query(value = "select avg(e.age) from  Employee e",nativeQuery = true)
    public Integer queryEmployee3();
}

注解式

 //查询指定的名称
    @Test
    public void testName1()throws Exception{
        List<Employee> list = employeeRepository.findByUsername("玉帝");
        for (Employee employee : list) {
            System.out.println(employee);
        }
    }
    //年龄小于<20
    @Test
    public void testName2()throws Exception{
        List<Employee> list = employeeRepository.findByAgeLessThan(20);
        for (Employee employee : list) {
            System.out.println(employee);
        }
    }
    //注解查询
    @Test
    public void testName3()throws Exception{
        Employee employee = employeeRepository.queryEmployee();
        System.out.println(employee);
    }
    //根据员工用户名和密码模糊查询
    @Test
    public void testName4()throws Exception{
        List<Employee> list = employeeRepository.queryEmployee1("%玉%", "%1%");
        for (Employee employee : list) {
            System.out.println(list);
        }
    }
    //根据员工用户名和年龄具体查询
    @Test
    public void testName5()throws Exception{
        List<Employee> list = employeeRepository.queryEmployee2("admin", 34);
        for (Employee employee : list) {
            System.out.println(employee);

        }
    }
    //查询员工的平均年龄
    @Test
    public void testName6()throws Exception{
        Integer integer = employeeRepository.queryEmployee3();
        System.out.println(integer);

    }

#0080FF

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Springdatajpa-day1

配置applicationContext.xml文件<?xml version="1.0" encoding="UTF-8"?><context:component-scan base-package="cn.itsource.pss.service" /><context:property-place...
复制链接

扫一扫