操作数据库的几种CURD方式
1、Hibernate
通过获取session，
private void addUser(){
//建立持久化对象
Users user=new Users();
user.setLoginName("Haige");
user.setLoginPwd("123456");
//1.初始化,读取配置文件hibernate.cfg.xml
Configuration config=new Configuration().configure();
//2.读取并解析映射文件(Users.hbm.xml)，创建sessionFactory
SessionFactory sessionFactory=config.buildSessionFactory();
//3.打开session
Session session=sessionFactory.openSession();
Transaction tx=null;
try {
tx=session.beginTransaction(); //4.开始一个事务
session.update(user);
session.delete(user);
session.save(user);
session.get(user.class, 4);
session.saveOrUpdate(student);
List<Users> studentList = session.createQuery("from User").list(); //5.持久化操作
tx.commit(); //6.提交事务
} catch (Exception e) {
if(tx!=null){
tx.rollback(); //事务回滚
}
e.printStackTrace();
}finally{
session.close(); //7.关闭session
}
}
2.spring-data-jpa
@Repository
public interface UserRepository extends JpaRepository<User,Integer>{
}
@Repository
public class UserDao {
@Autowired
private PropertyConfig propertyConfig;
@Autowired
private UserRepository userRepository;
@Transactional
public void saveUser(User user){
userRepository.saveAndFlush(user);
}
@Transactional
public User queryById(int id){
User user=(User) userRepository.findOne(id);
return user;
}
@Transactional
public List queryAll(){
List userList=userRepository.findAll();
return userList;
}
}
其他：注解写sql
（1）UserDao.java
package com.niugang.dao;
import java.util.List;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;
import org.springframework.stereotype.Repository;
import com.niugang.entity.User;
/**
* JpaRepository springboot已经自动配置了，也已经注入数据源了
*
* @author
*
*/
@Repository
public interface UserDao extends JpaRepository<User, Integer> {
/**
* ？加数字表示占位符，？1代表在方法参数里的第一个参数，区别于其他的index，这里从1开始
*/
// select * from User where name = ?1 注意不能写成*
@Query(value = "select u from User u where u.name = ?1")
User findUserByName1(String name);
/**
* =:加上变量名，这里是与方法参数中有@Param的值匹配的，而不是与实际参数匹配的 和上面第一个原理是一样的
*/
@Query(value = "select u from User u where u.name = :name")
User findUserByName2(@Param("name") String username);
/**
* 通过原生sql 进行查询
* 开启nativeQuery=true，在value里可以用原生SQL语句完成查询
*/
@Query(nativeQuery = true, value = "select * from user u where u.name = :name")
User findUserByNativeSQL(@Param("name") String username);
/**
* 模糊查询 这里的%只能放在占位的前面，后面不行
*/
@Query(value = "select u from User u where u.name like %?1% ")
List<User> findUserLike(String name);
/**
* 调条件分页查询 Pageable：spring-data-jpa自带接口
*
* @param name
* :查询条件name
* @param page:分页对象
* @return
*/
@Query(value = "select u from User u where u.name like %?1% ")
Page<User> findUserLikeByPage(String name, Pageable page);
/**
* @Query查询不支持，排序并且分页
* 源码分析
* if (hasParameterOfType(method, Pageable.class)) {
if (!isStreamQuery()) {
assertReturnTypeAssignable(method, Slice.class, Page.class, List.class);
}
if (hasParameterOfType(method, Sort.class)) {
throw new IllegalStateException(String.format("Method must not have Pageable *and* Sort parameter. "
+ "Use sorting capabilities on Pageble instead! Offending method: %s", method.toString()));
}
}
*
* @param sort ：排序对象 org.springframework.data.domain.Sort
* @return
*/
@Query(value = "select u from User u")
List<User> findUserLikeBySort(Sort sort);
}
（2） findUserLikeByPage(String name, Pageable page)接口解释：
public Page<User> findUserByPage(String name) {
PageRequest pageRequest = new PageRequest(0, 4);
return userDao.findUserLikeByPage(name, pageRequest);
}
（3）排序测试代码
/**
* 单条件排序
*/
public List<User> findListSortSingleCondition(){
//id升序查询
Sort sort = new Sort(Sort.Direction.ASC,"id");
return userDao.findUserLikeBySort(sort);
}
/**
* 多条件排序
*/
public List<User> findListSortMultiCondition(){
List<Order> orders=new ArrayList<Order>();
Order orderId = new Sort.Order(Sort.Direction.DESC,"id");
Order orderAge = new Sort.Order(Sort.Direction.DESC,"age");
orders.add(orderId);
orders.add(orderAge);
Sort sort = new Sort(orders);
return userDao.findUserLikeBySort(sort);
}
3.Spring的Jdbctemplate
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
/**
* 功能：设置数据库信息和数据源
*
* JdbcTemplat使用
* 1、导入jar包；2、设置数据库信息；3、设置数据源；4、调用jdbcTemplate对象中的方法实现操作
*/
public class JdbcTemplateObject {
DriverManagerDataSource dataSource;
JdbcTemplate jdbcTemplate;
public JdbcTemplateObject() {
// 设置数据库信息
this.dataSource = new DriverManagerDataSource();
this.dataSource.setDriverClassName("com.mysql.jdbc.Driver");
this.dataSource.setUrl("jdbc:mysql://192.168.184.130:3306/gxrdb");
this.dataSource.setUsername("root");
this.dataSource.setPassword("root");
// 设置数据源
this.jdbcTemplate = new JdbcTemplate(dataSource);
}
public DriverManagerDataSource getDataSource() {
return dataSource;
}
public void setDataSource(DriverManagerDataSource dataSource) {
this.dataSource = dataSource;
}
public JdbcTemplate getJdbcTemplate() {
return jdbcTemplate;
}
public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
}
public static void main(String[] args) {
// 设置数据库信息和据源
JdbcTemplateObject jdbcTemplateObject = new JdbcTemplateObject();
JdbcTemplate jdbcTemplate = jdbcTemplateObject.getJdbcTemplate();
//查询返回某一个值：查询表中数据总数
queryForOne(jdbcTemplate);
}
public static void queryForOne(JdbcTemplate jdbcTemplate) {
String sql = "select count(*) from user";
// 调用方法获得记录数
int count = jdbcTemplate.queryForObject(sql, Integer.class);
}
还可以实现RowMapper
/**
* 实现RowMapper接口，返回User对象
* */
public class MyRowMapper implements RowMapper<User>{
@Override
public User mapRow(ResultSet resultSet, int i) throws SQLException {
// 获取结果集中的数据
String name = resultSet.getString("name");
String age = resultSet.getString("age");
// 把数据封装成User对象
User user = new User();
user.setName(name);
user.setAge(age);
return user;
}
}
User user = jdbcTemplate.queryForObject(sql, new MyRowMapper(), "Tom");
4.Javaweb的jdbc
package helloworld.jdbcTemplate;
import org.springframework.jdbc.core.JdbcTemplate;
import java.sql.*;
import java.util.List;
/**
* 功能：通过JdbcTemplate实现查询操作
* 查询结果需要自己封装(实现RowMapper接口)
*/
public class JdbcTemplateDemo2 {
// JdbcTemplate使用步骤：
// 1、导入jar包；2、设置数据库信息；3、设置数据源；4、调用jdbcTemplate对象中的方法实现操作
public static void main(String[] args) {
// 设置数据库信息和据源
JdbcTemplateObject jdbcTemplateObject = new JdbcTemplateObject();
JdbcTemplate jdbcTemplate = jdbcTemplateObject.getJdbcTemplate();
// 插入数据
// insertData();
// 查询返回某一个值：查询表中数据总数
queryForOne(jdbcTemplate);
// 查询返回对象
queryForObject(jdbcTemplate);
// 查询返回list集合
queryForList(jdbcTemplate);
// 使用JDBC底层实现查询
queryWithJDBC();
}
// 插入数据
public static void insertData() {
JdbcTemplateObject jdbcTemplateObject = new JdbcTemplateObject();
JdbcTemplate jdbcTemplate = jdbcTemplateObject.getJdbcTemplate();
// 调用jdbcTemplate对象中的方法实现操作
String sql = "insert into user value(?,?,?)";
//表结构：id（int、自增）,name(varchar 100),age(int 10)
int rows = jdbcTemplate.update(sql, null, "Tom", 35);
System.out.println("插入行数：" + rows);
}
/**
* 查询返回某一个值：查询表中数据总数
*/
public static void queryForOne(JdbcTemplate jdbcTemplate) {
String sql = "select count(*) from user";
// 调用方法获得记录数
int count = jdbcTemplate.queryForObject(sql, Integer.class);
System.out.println("数据总数：" + count);
}
/**
* 功能：查询返回单个对象
* 步骤：新建MyRowMapper类实现RowMapper接口，重写mapRow方法，指定返回User对象
*/
public static void queryForObject(JdbcTemplate jdbcTemplate) {
String sql = "select * from user where name = ?";
// 新建MyRowMapper类实现RowMapper接口，重写mapRow方法，指定返回User对象
User user = jdbcTemplate.queryForObject(sql, new MyRowMapper(), "Tom");
System.out.println(user);
}
/**
* 功能：查询返回对象集合
* 步骤：新建MyRowMapper类实现RowMapper接口，重写mapRow方法，指定返回User对象
*/
public static void queryForList(JdbcTemplate jdbcTemplate) {
String sql = "select * from user";
// 第三个参数可以省略
List<User> users = jdbcTemplate.query(sql, new MyRowMapper());
System.out.println(users);
}
/**
* 使用JDBC底层实现查询
*/
public static void queryWithJDBC() {
Connection conn = null;
PreparedStatement psmt = null;
ResultSet rs = null;
String jdbcUrl = "jdbc:mysql://localhost:3306/test";
try {
// 加载驱动
Class.forName("com.mysql.jdbc.Driver");
// 创建连接
conn = DriverManager.getConnection(jdbcUrl, "root", "root");
String sql = "select * from user where name = ?";
// 预编译sql
psmt = conn.prepareStatement(sql);
// 从1开始，没有就不需要
psmt.setString(1, "Tom");
// 执行sql
rs = psmt.executeQuery();
// int num = psmt.executeUpdate(); //增删改，返回操作记录数
// 遍历结果集
while (rs.next()) {
//根据列名查询对应的值，也可以是位置序号
String name = rs.getString("name");
String age = rs.getString("age");
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
rs.close();
psmt.close();
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
}
5.mybatis的方式
public interface UserDao{
public User findUserById(int id) throws Exception;
}
mapper.xml文件
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--
namespace命名空间，作用就是对sql进行分类管理，理解为sql隔离
注意：使用mapper代理方法开发，namespace有特殊重要的作用
-->
<mapper namespace="com.dao.UserDao">
<!-- 在映射文件中配置很多sql语句 .Dao.UserDao -->
<!--
通过select执行数据库查询
id：标识映射文件中的sql，将sql语句封装到mappedStatement对象中，称为statement的id
parameterType:指定输入参数的类型 ,这里指定int型
#{id}:其中的id标识接收输入的参数，参数名称是id，如果输入参数是简单类型，#{}中的参数吗可以任意
resultType:指定sql输出结果的所映射的java对象类型,select指定resultType表示将单条记录映射成的java对象
-->
<select id="findUserById" parameterType="java.lang.Integer" resultType="com.entity.User">
SELECT * FROM T_UserTest WHERE id=#{id}
</select>
</mapper>
配置文件：
<bean id="mySqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<!-- 自动扫描mapping.xml文件 -->
<property name="mapperLocations" value="classpath:com/map/UserMapper.xml"></property>
</bean>
<!-- 所在包名，Spring会自动查找其下的类 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.dao" />
<!-- <property name="sqlSessionFactoryBeanName" ref="sqlSessionFactory"></property> -->
</bean>
