Day 06 ORM对象关系映射

作者: 忆曦雪_ | 来源:发表于2019-03-12 17:27 被阅读0次

Day 06 ORM对象关系映射
hibernate相关概念
三、Hibernate_多表关系&级联操作&外键维护
ORM
Django中ORM介绍和字段及字段参数
SQLAlchemy ORM
MyBatis入门学习总结
Hibernate框架(1) - 配置文件
定义ORM模型，并将ORM模型映射到数据库中
Hibernate初探之单表映射

一、 ORM简介

对象关系映射（Object Relational Mapping，简称ORM）模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。简单的说，ORM是通过使用描述对象和数据库之间映射的元数据，将程序中的对象自动持久化到关系数据库中。

百度百科：ORM

二、Spring中对哪些ORM框架提供支撑

hibernate：Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的JaveEE架构中取代CMP，完成数据持久化的重任。
mybatis：MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。
本节实例采用封装的Mybatis通用Mapper和Spring整合，演示基本的单表CRUD，复杂的SQL建议自定义
tk-mybatis地址：
JPA：JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。

三、Mybatis 通用 Mapper 和 Spring 集成练习

*(我用的是MySQL) 建好数据库db_spring和第一个表格t_user

创建表格

创建一个新模块ORM

布局如图
添加依赖(版本号自行选择最新版)

<mysql.version>5.1.47</mysql.version>
        <mybatis.version>3.5.0</mybatis.version>
        <mybatis-spring.version>2.0.0</mybatis-spring.version>
        <tk-mybatis.version>4.1.5</tk-mybatis.version>
        <druid.version>1.1.14</druid.version>

<!--spring-jdbc依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
       <!--mysql依赖-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>${mysql.version}</version>
        </dependency>
        <!--mybatis依赖-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>${mybatis.version}</version>
        </dependency>
       <!--mybatis-spring依赖-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>${mybatis-spring.version}</version>
        </dependency>
      <!--通用mapper依赖-->
        <dependency>
            <groupId>tk.mybatis</groupId>
            <artifactId>mapper</artifactId>
            <version>${tk-mybatis.version}</version>
        </dependency>
        <!--druid依赖-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>${druid.version}</version>
        </dependency>
    </dependencies>

jdbc.properties文件(注意自己修改自己的数据库账号密码)

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/db_spring?useUnicode=true&characterEncoding=utf-8
jdbc.username=root
jdbc.password=root

spring_mybatis.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:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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">

    <!--读入外部数据库连接属性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--扫描Service包的组件-->
    <context:component-scan base-package="com.spring.orm.service"/>

    <!--通过druid配置数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          init-method="init" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <!-- 初始化大小 -->
        <property name="initialSize" value="20"/>
        <!-- 连接池最大使用连接数量 -->
        <property name="maxActive" value="20"/>
        <!-- 连接池最小空闲 -->
        <property name="minIdle" value="0"/>
        <!-- 配置获取连接等待超时的时间 -->
        <property name="maxWait" value="60000"/>
        <!-- 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 -->
        <property name="timeBetweenEvictionRunsMillis" value="60000"/>
        <!-- 配置一个连接在池中最小生存的时间，单位是毫秒 -->
        <property name="minEvictableIdleTimeMillis" value="300000"/>
        <!-- 连接空闲时测试是否有效 -->
        <property name="testWhileIdle" value="false"/>
        <!-- 获取连接时测试是否有效 -->
        <property name="testOnBorrow" value="false"/>
        <!-- 归还连接时是否测试有效 -->
        <property name="testOnReturn" value="false"/>
        <!-- 打开PSCache缓存，并且指定每个连接上PSCache的大小 -->
        <property name="poolPreparedStatements" value="true"/>
        <property name="maxPoolPreparedStatementPerConnectionSize" value="20"/>
    </bean>

    <!-- 配置mybatis的Session -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.spring.orm.entity"/>
    </bean>

    <!-- 配置通用Mapper -->
    <bean class="tk.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.spring.orm.dao"/>
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <property name="markerInterface" value="com.spring.orm.dao.BaseDAO"/>
        <property name="properties">
            <value>
                mappers = com.spring.orm.dao.BaseDAO
                IDENTITY = MYSQL
            </value>
        </property>
    </bean>

    <!--事务管理bean -->
    <bean id="manager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!-- 使用声明式事务 -->
    <tx:annotation-driven transaction-manager="manager"/>
</beans>

User类

package com.spring.orm.entity;

import lombok.Data;

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

@Table(name="t_user")
@Data
public class User {
//    标注主键
   @Id
   @GeneratedValue(strategy = GenerationType.IDENTITY)
   private Long id;
   private String account;
   private String password;
   private Integer credits;
}

BaseDAO接口

package com.spring.orm.dao;

import tk.mybatis.mapper.common.Mapper;
import tk.mybatis.mapper.common.MySqlMapper;

/**
 * 通用DAO接口
 */
public interface BaseDAO<T> extends Mapper<T>, MySqlMapper<T> {
}

UserDAO接口

package com.spring.orm.dao;

import com.spring.orm.entity.User;

/**
 * UserDAO，继承通用DAO接口基础的CRUD功能
 */
public interface UserDAO extends BaseDAO<User> {
}

UserService接口

package com.spring.orm.service;

import com.spring.orm.entity.User;

import java.util.List;

public interface UserService {
    /**
     * 新增用户
     */
    int insertUser(User user);

    /**
     * 根据id删除用户
     */
    int deleteUser(long id);

    /**
     * 更新用户
     *
      */
    int updateUser(User user);

    /**
     * 查询所有用户
     */
    List<User> selectUsers();

    /**
     * 根据id查询用户
       */
    User getUser(long id);
}

UserServiceImpl实现类

package com.spring.orm.service.impl;

import com.spring.orm.dao.UserDAO;
import com.spring.orm.entity.User;
import com.spring.orm.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
@Transactional
public class UserServiceImpl implements UserService {
    @Autowired
    private UserDAO userDAO;

    @Override
    public int insertUser(User user) {
        return userDAO.insert(user);
    }

    @Override
    public int deleteUser(long id) {
        return userDAO.deleteByPrimaryKey(id);
    }

    @Override
    public int updateUser(User user) {
        return userDAO.updateByPrimaryKey(user);
    }

    @Override
    public List<User> selectUsers() {
        return userDAO.selectAll();
    }

    @Override
    public User getUser(long id) {
        return userDAO.selectByPrimaryKey(id);
    }
}

单元测试类

package com.spring.orm.service.Impl;

import com.spring.orm.entity.User;
import com.spring.orm.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.util.List;

import static org.junit.Assert.*;
//指定单元测试环境
@RunWith(SpringJUnit4ClassRunner.class)
//指定配置文件路径
@ContextConfiguration(locations={"/Spring_mybatis.xml"})
public class UserServiceImplTest {
    @Autowired
    private UserService userService;

    @Test
    public void insertUser() {
        User user = new User();
        user.setAccount("1005");
        user.setPassword("123123");
        user.setCredits(666);
        int n = userService.insertUser(user);
        assertEquals(1, n);
    }

   @Test
    public void selectUsers() {
        List<User> users = userService.selectUsers();
        users.forEach(user -> System.out.println(user));
    }
    @Test
    public void deleteUser() {
        int n = userService.deleteUser(5);
        assertEquals(1,n);
    }
    @Test
    public void updateUser() {
        User user = userService.getUser(3);
        user.setPassword("888888");
        user.setCredits(250);
        int n = userService.updateUser(user);
        assertEquals(1, n);
    }
    @Test
    public void getUser() {
        User user = userService.getUser(1);
        System.out.println(user);
    }
}

运行截图

查.jpg

改.jpg

根据ID查.jpg

删.jpg

增.jpg

Day 06 ORM对象关系映射
一、 ORM简介对象关系映射（Object Relational Mapping，简称ORM）模式是一种为了解决...
hibernate相关概念
ORM（对象关系映射） ORM的全称是Object Relational Mapping，即对象关系映射，它的实质...
三、Hibernate_多表关系&级联操作&外键维护
一、一对多的ORM关系映射 ORM ： Object Relational Mapping 。对象关系映射...
ORM
ORM框架ORM全称对象关系映射（Object/Relation Mapping），指将Java对象状态自动映射到...
Django中ORM介绍和字段及字段参数
Object Relational Mapping(ORM) ORM介绍 ORM概念对象关系映射（Object ...
SQLAlchemy ORM
何谓ORM Object Relational Mapping(对象关系映射) ORM用途 ORM把对象模型表示的...
MyBatis入门学习总结
ORM模型简介 ORM:对象关系映射(ObjectRelationMapping) Object对象指的是Jav...
Hibernate框架(1) - 配置文件
ORM概念 ORM, 对象关系映射！O : Object对象R : Realtion关系(关系型数据库: MySQ...
定义ORM模型，并将ORM模型映射到数据库中
对象关系映射（Object Relational Mapping，简称ORM，翻译为中文为模型关系映射或者对象关系...
Hibernate初探之单表映射
什么是ORM ORM(Object/Relationship Mapping)：对象/关系映射为什么需要ORM ...