SpringData入门案列

最新推荐文章于 2023-06-02 17:44:52 发布

静静七分醉

最新推荐文章于 2023-06-02 17:44:52 发布

阅读量366

点赞数

分类专栏：大数据文章标签： SpringData

本文链接：https://blog.csdn.net/m0_37657725/article/details/93381013

版权

大数据专栏收录该内容

4 篇文章 0 订阅

订阅专栏

springData基础

1.创建项目，导入依赖：pom.xml

2.配置Spring核心配置文件：ApplicationContext.xml

3.创建实体：

4.Repository接口

5.Repository接口中方法定义约定

6.@Query注解自定义SQL

7.CrudRepository接口

8.PagingAndSortingRepository接口

1.创建项目，导入依赖：pom.xml

<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>SpringDataJPA_Demo01</groupId>
	<artifactId>SpringDataJPA_Demo01</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>SpringDataJPA_Demo01</name>
	<url>http://maven.apache.org</url>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
	</properties>

	<dependencies>
		<!-- junit测试框架 -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.10</version>
			<scope>test</scope>
		</dependency>
		<!-- mySql数据库驱动 -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.38</version>
		</dependency>
		<!-- Spring容器 -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>4.3.5.RELEASE</version>
		</dependency>
		<!-- SpringData JDBC -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-jdbc</artifactId>
			<version>4.3.5.RELEASE</version>
		</dependency>
		<!--SpringData 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>
	</dependencies>
</project>

2.配置Spring核心配置文件：ApplicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:tx="http://www.springframework.org/schema/tx" 
	xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xsi:schemaLocation="
		http://www.springframework.org/schema/beans 
		http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context 
		http://www.springframework.org/schema/context/spring-context-4.0.xsd
		http://www.springframework.org/schema/tx 
		http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
		http://www.springframework.org/schema/data/jpa 
		http://www.springframework.org/schema/data/jpa/spring-jpa-1.3.xsd
	">

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

	<!-- 2.配置实体管理器工厂 -->
	<bean id="entityManagerFactory"
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<!-- 数据源 -->
		<property name="dataSource" ref="dataSource"></property>
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter" />
		</property>
		<!-- 配置扫描哪个包去寻找实体配置 -->
		<property name="packagesToScan" value="com.lj.domain" />
		<!-- JPA相关配置 -->
		<property name="jpaProperties">
			<props>
				<!-- 命名策略 -->
				<prop key="hibernate.ejb.naming_strategy">org.hibernate.cfg.ImprovedNamingStrategy</prop>
				<!-- 数据库方言 -->
				<prop key="hibernate.dialect">org.hibernate.dialect.MySQL5InnoDBDialect</prop>
				<!-- 是否显示sql -->
				<prop key="hibernate.show_sql">true</prop>
				<!-- 是否要格式化sql -->
				<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.lj"
		entity-manager-factory-ref="entityManagerFactory" />

	<!-- 6.配置spring包扫描 -->
	<context:component-scan base-package="com.lj.domain"></context:component-scan>

</beans>

在mysql建表

create database demodb;

use demodb;

3.创建实体：

添加注解——

@Entity 声明当前bean映射称为一个Entity实体，Entity实体会对应数据库中的表

@Id 当前属性是当前实体的Id属性

@GeneratedValue 指定该属性自增

@Column 指定列的名字和长度

package com.lj.domain;

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

@Entity(name="stu")
public class Student {
	private int id;
	private String name;
	private int age;
	
	public Student() {
	}

	public Student(int id, String name, int age) {
		this.id = id;
		this.name = name;
		this.age = age;
	}

	@Id
	@GeneratedValue
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	@Column(name="username",length=20)
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	@Override
	public String toString() {
		return "Student [id=" + id + ", name=" + name + ", age=" + age + "]";
	}
}

4.Repository接口

SpringDataJPA的核心接口是Repository，可以通过自定义接口继承该接口，在其中定义方法实现对实体的管理

可以在该接口的实现类中定义方法来实现对实体的管理，这些方法的名称是基于约定而来的，按照约定定义方法，SpringData将会按照约定操作表。

package com.lj.repository;

import java.util.List;

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.Repository;

import com.lj.domain.Student;

public interface StudentRepository extends Repository<Student, Integer> {
    //	可以通过将nativeQuery属性设置为true来表明之后的value中是原生的sql语句
	@Query(nativeQuery=true,value="select * from stu where id between ?1 and ?2")
	public List<Student> queryBetween2(int begin,int end);

	//可以通过?n的方式在JPA Query语句中引用方法中的参数
	@Query("select o from stu o where o.id between ?1 and ?2")
	public List<Student> queryBetween(int begin,int end);

	//此处注意，写的不是sql，而是JPA Query语句，操作的不是数据库中的表，而是实体，所以不要写表名，而是写实体名称
	@Query("select count(1) from stu o ")
	public Integer getCount();

	public List<Student> findByAgeBetweenAndNameLikeAndIdGreaterThan(int begin, int end, String nameLike, int id);

	public List<Student> findByAgeBetween(int begin, int end);

	public Student findByNameAndAge(String name, int age);

	public Student findByName(String name);

	public void exists(Integer id);

	public void delete(Integer id);

	public void save(Student student);

}

进行测试看：

package com.lj.test;

import java.util.List;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.lj.domain.Student;
import com.lj.repository.StudentRepository;

public class Test01 {
	
	/**
	 * 查询
	 */
	@Test
	public void test11(){
		//1.初始化Spring容器
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		//2.获取StudentRepository
		StudentRepository repository = context.getBean(StudentRepository.class);
		//3.调用方法
		List<Student> list = repository.queryBetween2(2, 4);
		System.out.println(list);
	}
	/**
	 * 查询
	 */
	@Test
	public void test10(){
		//1.初始化Spring容器
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		//2.获取StudentRepository
		StudentRepository repository = context.getBean(StudentRepository.class);
		//3.调用方法
		List<Student> list = repository.queryBetween(2, 4);
		System.out.println(list);
	}
	@Test
	public void test09(){
		//1.初始化Spring容器
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		//2.获取StudentRepository
		StudentRepository repository = context.getBean(StudentRepository.class);
		//3.调用方法
		int count = repository.getCount();
		System.out.println(count);
	}
	
	/**
	 * 查询
	 */
	@Test
	public void test08(){
		//1.初始化Spring容器
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		//2.获取StudentRepository
		StudentRepository repository = context.getBean(StudentRepository.class);
		//3.调用方法
		List<Student> list = repository.findByAgeBetweenAndNameLikeAndIdGreaterThan(20, 30, "z%", 3);
		System.out.println(list);
	}
	
	/**
	 * 查询
	 */
	@Test
	public void test07(){
		//1.初始化Spring容器
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		//2.获取StudentRepository
		StudentRepository repository = context.getBean(StudentRepository.class);
		//3.调用方法
		List<Student> list = repository.findByAgeBetween(20, 30);
		System.out.println(list);
	}
	
	/**
	 * 查询
	 */
	@Test
	public void test06(){
		//1.初始化Spring容器
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		//2.获取StudentRepository
		StudentRepository repository = context.getBean(StudentRepository.class);
		//3.调用方法
		Student stu = repository.findByNameAndAge("zl",33);
		System.out.println(stu);
	}
	
	/**
	 * 查询
	 */
	@Test
	public void test05(){
		//1.初始化Spring容器
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		//2.获取StudentRepository
		StudentRepository repository = context.getBean(StudentRepository.class);
		//3.调用方法
		Student stu = repository.findByName("ww");
		System.out.println(stu);
	}
	
	/**
	 * 删除
	 */
	@Test
	public void test04(){
		//1.初始化Spring容器
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		//2.获取StudentRepository
		StudentRepository repository = context.getBean(StudentRepository.class);
		//3.调用方法
		repository.delete(1);
	}
	
	/**
	 * 修改
	 */
	@Test
	public void test03(){
		//1.初始化Spring容器
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		//2.获取StudentRepository
		StudentRepository repository = context.getBean(StudentRepository.class);
		//3.调用方法
		Student stu = new Student(1,"zsf",29);
		repository.save(stu);
	}
	
	/**
	 * 新增
	 */
	@Test
	public void test02(){
		//1.初始化Spring容器
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
		//2.获取StudentRepository
		StudentRepository repository = context.getBean(StudentRepository.class);
		//3.调用方法
		Student stu = new Student(0,"zs",19);
		repository.save(stu);
	}
	
	/**
	 * 初始化容器时创建表
	 */
	@Test
	public void test01(){
		//1.初始化Spring容器
		ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
	}
}

5.Repository接口中方法定义约定

查询操作：查询以findBy开头，后跟查询条件，多个查询条件之间可以通过and或or连接

6.@Query注解自定义SQL

可以在Repository中的方法上使用@Query注解直接声明该方法要执行的操作语句，则此时调用该方法会直接执行指定SQL，而不参照默认方法名对应语句规则。

7.CrudRepository接口

自带了增删改查相关方法的Repository接口的子接口

public interface StudentRepository2 extends CrudRepository<Student, Integer> {

}

8.PagingAndSortingRepository接口

可以附带分页和排序效果的Repository接口的子接口

public interface StudentRepository3 extends PagingAndSortingRepository<Student, Integer> {

}

静静七分醉

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
SpringData入门案列

springData基础目录1.创建项目，导入依赖：pom.xml2.配置Spring核心配置文件：ApplicationContext.xml3.创建实体：4.Repository接口5.Repository接口中方法定义约定6.@Query注解自定义SQL7.CrudRepository接口8.PagingAndSortingRepository接口1....
复制链接

扫一扫

专栏目录