Spring Data CRUD

编程语言 2018-05-12 21:41:37 阅读次数: 1

原创转载请注明出处：http://agilestyle.iteye.com/blog/2299253

 

1.Maven Dependency

<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>org.fool.springdata</groupId>
	<artifactId>springdata</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

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

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

	<dependencies>
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-jpa</artifactId>
			<version>1.10.1.RELEASE</version>
		</dependency>

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

		<dependency>
			<groupId>javax.inject</groupId>
			<artifactId>javax.inject</artifactId>
			<version>1</version>
		</dependency>

		<dependency>
			<groupId>com.google.guava</groupId>
			<artifactId>guava</artifactId>
			<version>19.0</version>
		</dependency>

		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.4</version>
		</dependency>

		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.39</version>
		</dependency>

		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>4.2.5.RELEASE</version>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.12</version>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>org.dbunit</groupId>
			<artifactId>dbunit</artifactId>
			<version>2.5.2</version>
		</dependency>

		<dependency>
			<groupId>com.github.springtestdbunit</groupId>
			<artifactId>spring-test-dbunit</artifactId>
			<version>1.3.0</version>
			<scope>test</scope>
		</dependency>

		<dependency>
			<groupId>org.hsqldb</groupId>
			<artifactId>hsqldb</artifactId>
			<version>2.3.4</version>
			<scope>test</scope>
		</dependency>
	</dependencies>
</project>

 

2.Project Structure


 

3.Spring Config xml - beans.xml

<?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:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc" 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/context     
        http://www.springframework.org/schema/context/spring-context.xsd    
        http://www.springframework.org/schema/tx     
        http://www.springframework.org/schema/tx/spring-tx.xsd    
        http://www.springframework.org/schema/aop    
        http://www.springframework.org/schema/aop/spring-aop.xsd
		http://www.springframework.org/schema/jdbc 
		http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
		http://www.springframework.org/schema/data/jpa
    	http://www.springframework.org/schema/data/jpa/spring-jpa.xsd">

	<jpa:repositories base-package="org.fool.springdata.repository" />

	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory" />
	</bean>

	<bean id="entityManagerFactory"
		class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="jpaVendorAdapter" ref="jpaVendorAdapter" />
		<property name="packagesToScan" value="org.fool.springdata.domain" />
	</bean>

	<bean id="dataSource"
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="com.mysql.jdbc.Driver" />
		<property name="url" value="jdbc:mysql://localhost/springdata?useUnicode=true&amp;characterEncoding=UTF-8" />
		<property name="username" value="root" />
		<property name="password" value="123456" />
	</bean>

	<bean id="jpaVendorAdapter"
		class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
		<property name="generateDdl" value="true" />
		<property name="database" value="MYSQL" />
		<property name="showSql" value="true" />
	</bean>
</beans>

 

4. Domain - Customer.java

package org.fool.springdata.domain;

import java.util.Date;

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

import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;

@Entity
public class Customer {
	@Id
	@GeneratedValue(strategy = GenerationType.IDENTITY)
	private Long id;
	private String firstName;
	private String lastName;
	private String address;
	private Date registerDate;

	public Customer() {
	}

	public Customer(String firstName, String lastName, String address, Date registerDate) {
		super();
		this.firstName = firstName;
		this.lastName = lastName;
		this.address = address;
		this.registerDate = registerDate;
	}

	public Long getId() {
		return id;
	}

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

	public String getFirstName() {
		return firstName;
	}

	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}

	public String getLastName() {
		return lastName;
	}

	public void setLastName(String lastName) {
		this.lastName = lastName;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	public Date getRegisterDate() {
		return registerDate;
	}

	public void setRegisterDate(Date registerDate) {
		this.registerDate = registerDate;
	}

	@Override
	public String toString() {
		return ToStringBuilder.reflectionToString(this, ToStringStyle.SHORT_PREFIX_STYLE);
	}
}

 

5. Repository - CustomerRepository.java

package org.fool.springdata.repository;

import java.util.List;

import org.fool.springdata.domain.Customer;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.data.repository.query.Param;

public interface CustomerRepository extends CrudRepository<Customer, Long> {
	List<Customer> findByLastName(String lastName);

	List<Customer> findByAddress(String address);

	@Query("select c from Customer c where c.firstName = :name or c.lastName = :name")
	List<Customer> findByFirstNameOrLastName(@Param("name") String name);
	
	@Query("select c from Customer c where c.firstName = ?1 and c.lastName = ?2")
	List<Customer> findByFirstNameAndLastName(String firstName, String lastName);
}

 

6. Unit Test - CustomerTest.java

package org.fool.springdata.test;

import java.util.Date;
import java.util.List;

import javax.inject.Inject;

import org.fool.springdata.domain.Customer;
import org.fool.springdata.repository.CustomerRepository;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.google.common.collect.Lists;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:beans.xml")
public class CustomerTest {
	@Inject
	private CustomerRepository customerRepository;

	private Customer customer;
	private List<Customer> customerList;

	@Test
	public void testFindByLastname() {
		List<Customer> cList = customerRepository.findByLastName("fei");
		cList.forEach(c -> System.out.println(c));
	}

	@Test
	public void testFindByAddress() {
		customerRepository.findByAddress("ShuGuo").forEach(c -> System.out.println(c));
	}

	@Test
	public void testFindByFirstNameOrLastName() {
		customerRepository.findByFirstNameOrLastName("Liu").forEach(c -> System.out.println(c));
	}

	@Test
	public void testFindByFirstNameAndLastName() {
		customerRepository.findByFirstNameAndLastName("Liu", "Shan").forEach(c -> System.out.println(c));
	}

	@Test
	public void testSave() {
		customer = new Customer();
		customer.setFirstName("Cao");
		customer.setLastName("Cao");
		customer.setAddress("WeiGuo");
		customer.setRegisterDate(new Date());

		Customer customer1 = new Customer("Liu", "Bei", "ShuGuo", new Date());
		Customer customer2 = new Customer("Guan", "Yu", "ShuGuo", new Date());
		Customer customer3 = new Customer("Zhang", "Fei", "ShuGuo", new Date());
		Customer customer4 = new Customer("Liu", "Shan", "ShuGuo", new Date());

		customerList = Lists.newArrayList(customer1, customer2, customer3, customer4);

		customerRepository.save(customer);
		customerRepository.save(customerList);
	}

	@Test
	public void testFindOne() {
		Customer c = customerRepository.findOne(11L);
		System.out.println(c);
	}

	@Test
	public void testFindAll() {
		List<Customer> cList = Lists.newArrayList(customerRepository.findAll());

		cList.forEach(c -> System.out.println(c));
	}

	@Test
	public void testDeleteAll() {
		List<Customer> cList = Lists.newArrayList(customerRepository.findAll());

		customerRepository.delete(cList);
	}
	
	@Test
	public void testUpdateOne() {
		Customer c = customerRepository.findOne(11L);
		c.setFirstName("Cao");
		c.setLastName("Pi");
		
		customerRepository.save(c);
	}
}

 

7.使用DBUnit+HSQLDB进行单元测试

DALConfigTest.java

package org.fool.springdata.dal.config;

import java.util.Properties;

import javax.inject.Inject;
import javax.sql.DataSource;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement
@PropertySource("classpath:db.properties")
@EnableJpaRepositories("org.fool.springdata.repository")
@ComponentScan("org.fool.springdata.domain")
public class DALConfigTest {
	private static final String JDBC_DRIVER = "jdbc.driver";
	private static final String JDBC_URL = "jdbc.url";
	private static final String JDBC_USERNAME = "jdbc.username";
	private static final String JDBC_PASSWORD = "jdbc.password";

	private static final String HIERNATE_DIALECT = "hibernate.dialect";
	private static final String HIERNATE_FORMAT_SQL = "hibernate.format_sql";
	private static final String HIBERNATE_EJB_NAMING_STRATEGY = "hibernate.ejb.naming_strategy";
	private static final String HIBERNATE_SHOW_SQL = "hibernate.show_sql";
	private static final String HIBERNATE_HBM2DDL_AUTO = "hibernate.hbm2ddl.auto";

	@Inject
	private Environment environment;

	@Bean
	public JpaTransactionManager transactionManager() throws ClassNotFoundException {
		JpaTransactionManager transactionManager = new JpaTransactionManager();

		transactionManager.setEntityManagerFactory(entityManagerFactory().getObject());

		return transactionManager;
	}

	@Bean
	public LocalContainerEntityManagerFactoryBean entityManagerFactory() throws ClassNotFoundException {
		LocalContainerEntityManagerFactoryBean entityManagerFactoryBean = new LocalContainerEntityManagerFactoryBean();

		Properties jpaProperties = new Properties();
		jpaProperties.put(HIERNATE_DIALECT, environment.getRequiredProperty(HIERNATE_DIALECT));
		jpaProperties.put(HIERNATE_FORMAT_SQL, environment.getRequiredProperty(HIERNATE_FORMAT_SQL));
		jpaProperties.put(HIBERNATE_SHOW_SQL, environment.getRequiredProperty(HIBERNATE_SHOW_SQL));
		jpaProperties.put(HIBERNATE_EJB_NAMING_STRATEGY, environment.getRequiredProperty(HIBERNATE_EJB_NAMING_STRATEGY));
		jpaProperties.put(HIBERNATE_HBM2DDL_AUTO, environment.getRequiredProperty(HIBERNATE_HBM2DDL_AUTO));
		entityManagerFactoryBean.setJpaProperties(jpaProperties);
		entityManagerFactoryBean.setDataSource(dataSource());
		entityManagerFactoryBean.setPackagesToScan("org.fool.springdata.domain");
		entityManagerFactoryBean.setJpaVendorAdapter(new HibernateJpaVendorAdapter());

		return entityManagerFactoryBean;
	}

	@Bean
	public DataSource dataSource() {
		final DriverManagerDataSource dataSource = new DriverManagerDataSource();
		dataSource.setDriverClassName(environment.getRequiredProperty(JDBC_DRIVER));
		dataSource.setUrl(environment.getRequiredProperty(JDBC_URL));
		dataSource.setUsername(environment.getRequiredProperty(JDBC_USERNAME));
		dataSource.setPassword(environment.getRequiredProperty(JDBC_PASSWORD));

		return dataSource;
	}
}

 CustomerData.xml

<?xml version="1.0" encoding="UTF-8"?>
<dataset>
	<Customer id="1" firstName="Hello" lastName="World" address="China"
		registerDate="2016-06-20 00:00:00.0" />
</dataset>

 db.properties

#Database Configuration
jdbc.driver=org.hsqldb.jdbcDriver
jdbc.url=jdbc:hsqldb:mem:payment;shutdown=false
jdbc.username=sa
jdbc.password=

#Hibernate Configuration
hibernate.dialect=org.hibernate.dialect.HSQLDialect
hibernate.format_sql=true
hibernate.ejb.naming_strategy=org.hibernate.cfg.ImprovedNamingStrategy
hibernate.show_sql=true
hibernate.hbm2ddl.auto=create-drop

AbstractRepositoryTest.java

package org.fool.sprindata.dal.test;

import org.fool.springdata.dal.config.DALConfigTest;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.test.context.ContextConfiguration;

@ContextConfiguration
public class AbstractRepositoryTest {
	@Configuration
	@Import(DALConfigTest.class)
	static class Config {
	}
}

 CustomerTest.java

package org.fool.sprindata.dal.test;

import javax.inject.Inject;

import org.fool.springdata.repository.CustomerRepository;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.TestExecutionListeners;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.DependencyInjectionTestExecutionListener;

import com.github.springtestdbunit.DbUnitTestExecutionListener;
import com.github.springtestdbunit.annotation.DatabaseSetup;

@RunWith(SpringJUnit4ClassRunner.class)
@TestExecutionListeners({ DependencyInjectionTestExecutionListener.class, DbUnitTestExecutionListener.class })
public class CustomerTest extends AbstractRepositoryTest {
	@Inject
	private CustomerRepository customerRepository;

	@Test
	@DatabaseSetup("classpath:CustomerData.xml")
	public void testFindAll() {
		System.out.println(customerRepository.findAll());
	}

}

 

 

 

 

 

 

猜你喜欢

转载自agilestyle.iteye.com/blog/2299253
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
报告：Django 仍然是 74% 开发者的首选
《2024 年一季度互联网投融资运行情况》研究报告
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
BPM为企业带来的实际利益
好程序员web前端分享css常用属性缩写
Java文件下载（excel）
css样式的动态添加及显示和隐藏等零碎用法
axios全局配置以及拦截器
使用Logstash来实时同步MySQL和log日志数据到ES
C++获取当前时间（年月日、时分秒、毫秒）
Odoo产品分析 (四) -- 工具板块(11) -- 网站即时聊天(1)
Java环境配置正确，但是java、javac、java -version均返回“不是内部或外部命令，也不是可运行的程序或批处理文件”？
01 官网下载各种CentOS教程（超详细版）
每日归档
更多
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022