mybatis深入学习--关联映射

最新推荐文章于 2023-08-26 18:31:57 发布
最新推荐文章于 2023-08-26 18:31:57 发布
阅读量172 收藏
点赞数 1
分类专栏： 框架学习 文章标签： mybatis关系映射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40797063/article/details/93169481
版权

什么是关联映射

关联关系：现实世界中物体与物体之间的普遍的关系
关系型数据库：物体与物体之间的关系，可以用二张或多张表表示

映射就是一种关联关系，

关系：一对一关系 人和身份证
一对多关系 老师和学生
多对多关系 商品和人之间（）

强调的是：从一方出发，导航到另一方

关联映射案列分析

用户表：user
记录购买商品的用户信息
订单表：order
记录了用户所创建的订单
订单明细：orderdetail
记录了订单的详情及构面商品的信息
商品表：items
记录了商品信息

user和orders:一个用户可以创建多个订单 一对多

orders—user:一个订单只由一个用户创建

orders orderdetails:一个订单可以包含多个订单明细，因为一个订单购买多个商品
每个商品的购买信息在orderdetail记录，一对多
orderdetails orders:一个订单明细只能包含在一个订单中 一对一

items: 多对多关系（依托于订单和订单明细）

  • 解决方案
    创建视图或者是连接查询语句返回一个vo,存放了那个用户下了什么订单的信息。
    SELECT orders.*,user.username,user.address
    FROM orders,user WHERE orders.user_id = user.id
  • 工程目录结构
    在这在这里插入图片描述里插入图片描述
  • 导入jar包
    在这里插入图片描述
    在这里插入图片描述
  • 配置db.properties
oracle.driver=oracle.jdbc.driver.OracleDriver
oracle.url=jdbc:oracle:thin:@localhost:1521:orcl
oracle.user=scott
oracle.pwd=tiger
  • 配置mybatis.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<!-- 加载属性文件 -->
<properties resource="com/it/config/db.properties"></properties>

<!-- 配置 -->
<settings>
	<!-- 开启懒加载 -->
	<setting name="lazyLoadingEnabled" value="true"/>
	<!-- 关闭积极加载 -->
	<setting name="aggressiveLazyLoading" value="false"/>
	
	
	<!-- 开启二级缓存 -->
	<setting name="cacheEnabled" value="true"/>
</settings>


<!-- 起别名 -->
<typeAliases>
	<package name="com.it.bean"/>
</typeAliases>



<!-- 和spring整合后 environments配置将废除-->
	<environments default="development">
		<environment id="development">
		<!-- 使用jdbc事务管理，事务控制由mybatis-->
			<transactionManager type="JDBC" />
		<!-- 数据库连接池，由mybatis管理-->
			<dataSource type="POOLED">
				<property name="driver" value="${oracle.driver}" />
				<property name="url" value="${oracle.url}" />
				<property name="username" value="${oracle.user}" />
				<property name="password" value="${oracle.pwd}" />
			</dataSource>
		</environment>
	</environments>
	<!--加载映射文件-->
	<mappers>
	<!-- 当的映射文件的加载 -->
	 <!--  <mapper resource="com/it/bean/student.xml"/> -->
	<!--  <mapper class="com.it.dao.StudentMapper"/> -->
	 <package name="com.it.dao"></package>
	 </mappers>
</configuration>
  • User.java用户配置信息
package com.it.bean;

import java.io.Serializable;
import java.util.Date;
import java.util.List;

public class User implements Serializable{
	private int userid;
	private String username;
	private String usersex;
	private Date userbirth;
	private String useraddr;
	
	private List<Order> orderlist;

	public int getUserid() {
		return userid;
	}

	public void setUserid(int userid) {
		this.userid = userid;
	}

	public String getUsername() {
		return username;
	}

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

	public String getUsersex() {
		return usersex;
	}

	public void setUsersex(String usersex) {
		this.usersex = usersex;
	}

	public Date getUserbirth() {
		return userbirth;
	}

	public void setUserbirth(Date userbirth) {
		this.userbirth = userbirth;
	}

	public String getUseraddr() {
		return useraddr;
	}

	public void setUseraddr(String useraddr) {
		this.useraddr = useraddr;
	}

	public List<Order> getOrderlist() {
		return orderlist;
	}

	public void setOrderlist(List<Order> orderlist) {
		this.orderlist = orderlist;
	}

	public User(int userid, String username, String usersex, Date userbirth, String useraddr, List<Order> orderlist) {
		super();
		this.userid = userid;
		this.username = username;
		this.usersex = usersex;
		this.userbirth = userbirth;
		this.useraddr = useraddr;
		this.orderlist = orderlist;
	}

	public User() {
		super();
		// TODO Auto-generated constructor stub
	}

	@Override
	public String toString() {
		return "User [userid=" + userid + ", username=" + username + ", usersex=" + usersex + ", userbirth=" + userbirth
				+ ", useraddr=" + useraddr + ", orderlist=" + orderlist + "]";
	}

}
  • Order.java订单信息
package com.it.bean;

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

public class Order {
	private Integer order_id;
	private Integer user_id;
	private String order_number;
	private Date createtime;
	private String note;
	//关联查询对象
	private User user;
	//关联到订单明细
	private List<OrderDetail> orderdetail;
	
	public Integer getOrder_id() {
		return order_id;
	}
	public void setOrder_id(Integer order_id) {
		this.order_id = order_id;
	}
	public Integer getUser_id() {
		return user_id;
	}
	public void setUser_id(Integer user_id) {
		this.user_id = user_id;
	}
	public String getOrder_number() {
		return order_number;
	}
	public void setOrder_number(String order_number) {
		this.order_number = order_number;
	}
	public Date getCreatetime() {
		return createtime;
	}
	public void setCreatetime(Date createtime) {
		this.createtime = createtime;
	}
	public String getNote() {
		return note;
	}
	public void setNote(String note) {
		this.note = note;
	}
	public User getUser() {
		return user;
	}
	public void setUser(User user) {
		this.user = user;
	}
	public Order(Integer order_id, Integer user_id, String order_number, Date createtime, String note, User user) {
		super();
		this.order_id = order_id;
		this.user_id = user_id;
		this.order_number = order_number;
		this.createtime = createtime;
		this.note = note;
		this.user = user;
	}
	public Order() {
		super();
		// TODO Auto-generated constructor stub
	}
	@Override
	public String toString() {
		return "Order [order_id=" + order_id + ", user_id=" + user_id + ", order_number=" + order_number
				+ ", createtime=" + createtime + ", note=" + note + ", user=" + user + "]";
	}
	public List<OrderDetail> getOrderdetail() {
		return orderdetail;
	}
	public void setOrderdetail(List<OrderDetail> orderdetail) {
		this.orderdetail = orderdetail;
	}

}
  • Orderdetail.java订单详情
package com.it.bean;

public class OrderDetail {
	private int id;
	private int orders_id;
	private int items_id;
	private int items_num;
	
	private Items items;

	public int getId() {
		return id;
	}

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

	public int getOrders_id() {
		return orders_id;
	}

	public void setOrders_id(int orders_id) {
		this.orders_id = orders_id;
	}

	public int getItems_id() {
		return items_id;
	}

	public void setItems_id(int items_id) {
		this.items_id = items_id;
	}

	public int getItems_num() {
		return items_num;
	}

	public void setItems_num(int items_num) {
		this.items_num = items_num;
	}

	public Items getItems() {
		return items;
	}

	public void setItems(Items items) {
		this.items = items;
	}

	public OrderDetail(int id, int orders_id, int items_id, int items_num, Items items) {
		super();
		this.id = id;
		this.orders_id = orders_id;
		this.items_id = items_id;
		this.items_num = items_num;
		this.items = items;
	}

	public OrderDetail() {
		super();
		// TODO Auto-generated constructor stub
	}

	@Override
	public String toString() {
		return "OrderDetail [id=" + id + ", orders_id=" + orders_id + ", items_id=" + items_id + ", items_num="
				+ items_num + ", items=" + items + "]";
	}
	
	
	
}
  • Items.java商品信息
package com.it.bean;

import java.util.Date;

public class Items {
	private int id;
	private String name;
	private float price;
	private String pic;
	private Date createtime;
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public float getPrice() {
		return price;
	}
	public void setPrice(float price) {
		this.price = price;
	}
	public String getPic() {
		return pic;
	}
	public void setPic(String pic) {
		this.pic = pic;
	}
	public Date getCreatetime() {
		return createtime;
	}
	public void setCreatetime(Date createtime) {
		this.createtime = createtime;
	}
	public Items(int id, String name, float price, String pic, Date createtime) {
		super();
		this.id = id;
		this.name = name;
		this.price = price;
		this.pic = pic;
		this.createtime = createtime;
	}
	public Items() {
		super();
		// TODO Auto-generated constructor stub
	}
	@Override
	public String toString() {
		return "Items [id=" + id + ", name=" + name + ", price=" + price + ", pic=" + pic + ", createtime=" + createtime
				+ "]";
	}
	
	
}
  • 创建statement，并使用resutMap进行映射
  • 创建StudentMapper.java
package com.it.dao;

import java.util.List;

import com.it.bean.Order;
import com.it.bean.User;

public interface StudentMapper {
	/**
	 * 通过用户查询订单
	 * @return
	 */
	public List<Order> findUserByOrders();
	/**
	 * 通过订单明细查询顶大
	 * @return
	 */
	public List<Order> findOrderDetailsByOrders();
	/**
	 * 通过用户查询商品
	 * @return
	 */
	public List<User> findUserAndItems();
	/**
	 * 查询订单
	 * @return
	 */
	public List<Order> findOrder();
	/**
	 * 通过id查询用户
	 * @param id
	 * @return
	 */
	public User findUserById(String id);
}
  • 创建StudentMapper.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">
<mapper namespace="com.it.dao.StudentMapper">
	<!-- 引入二级缓存 -->
	<cache></cache>
	
	<!-- 延迟加载   通过订单查询用户信息  开始-->
	<resultMap type="com.it.bean.Order" id="findOrderMapping">
		 <id column="order_id" property="order_id"></id>
    	 <result column="user_id" property="user_id"></result>
    	 <result column="order_number" property="order_number"></result>
    	 <result column="createtime" property="createtime"></result>
    	 <result column="note" property="note"></result>
    	 <association property="user" javaType="com.it.bean.User" select="findUserById" column="user_id">
         
         
         </association>
	</resultMap>
	<select id="findOrder" resultMap="findOrderMapping">
		select * from orderInfo
	</select>
	<!-- 测试延迟加载   一级缓存 -->
	<select id="findUserById" parameterType="java.lang.String" resultType="com.it.bean.User" useCache="true" flushCache="true">
		select * from userInfo where userid=#{id}
	</select>
	<!-- 延迟加载   通过订单查询用户信息  结束-->

  <resultMap type="com.it.bean.Order" id="findUserByOrdersMap">
     <id column="order_id" property="order_id"></id>
     <result column="user_id" property="user_id"></result>
     <result column="order_number" property="order_number"></result>
     <result column="createtime" property="createtime"></result>
     <result column="note" property="note"></result>
     <!-- association就是用于说明关联的对象(user)的映射关系(User类和user表)
          association表示返回值只有一个对象的。
          property：就是Order类中的user属性
      -->
      <association property="user" javaType="com.it.bean.User">
          <id column="user_id" property="userid"></id>
          <result column="username" property="username"></result>
          <result column="usersex" property="usersex"></result>
          <result column="userbirth" property="userbirth"></result>
          <result column="useraddr" property="useraddr"></result>
      </association>
  </resultMap>
	<!-- 通过查询订单查询用户 -->
  <select id="findUserByOrders" resultMap="findUserByOrdersMap">
        SELECT 
        orders.*,users.username,users.useraddr,users.usersex,users.userbirth
        FROM orderInfo orders left join userInfo users
        on orders.user_id = users.userid
   </select>
   
   <!-- 查询订单   关联查询订单明细  开始  -->
   <resultMap type="com.it.bean.Order" id="findOrderDetailsByOrdersMap">
   		<id property="order_id" column="order_id"/>
   		<result property="user_id" column="user_id"/>
   		<result property="order_number" column="order_number"/>
   		<result property="createtime" column="createtime"/>
   		<result property="note" column="note"/>
   		<!-- 一对一 -->
   		<association property="user" javaType="com.it.bean.User">
   			<id property="userid" column="user_id"/>
   			<result property="username" column="username"/>
   			<result property="usersex" column="usersex"/>
   			<result property="userbirth" column="userbirth"/>
   			<result property="useraddr" column="useraddr"/>
   		</association>
   		<!-- 一对多 -->
   		<collection property="orderdetail" ofType="com.it.bean.OrderDetail">
   			<id property="id" column="orderdetail_id"/>
   			<result property="orders_id" column="order_id"/>
   			<result property="items_id" column="items_id"/>
   			<result property="items_num" column="items_num"/>
   		</collection>
   </resultMap>
   
   <select id="findOrderDetailsByOrders" resultMap="findOrderDetailsByOrdersMap">
   	   SELECT  orders.*,
       us.username,us.usersex,us.useraddr,us.userbirth,
       ordd.id AS orderdetail_id,
       ordd.items_id,
       ordd.items_num,
       ordd.order_id as orders_id
       FROM  orderInfo orders,userInfo us,orderdetail ordd
       WHERE orders.user_id=us.userid AND ordd.order_id=orders.order_id
   </select>
   <!-- 查询订单   关联查询订单明细  结束  -->
   
   
   <!-- 多对多关联映射   开始-->
   <resultMap type="com.it.bean.User" id="findUserAndItemsMapping">
   			<!-- 用户 -->
   			<id property="userid" column="user_id"></id>
   			<result property="username" column="username"></result>
   			<result property="usersex" column="usersex"></result>
   			<result property="userbirth" column="userbirth"></result>
   			<result property="useraddr" column="useraddr"></result>
   			<collection property="orderlist" ofType="com.it.bean.Order">
   				<!-- 订单 -->
   				<id property="order_id" column="order_id"></id>
   				<result property="user_id" column="user_id"></result>
   				<result property="order_number" column="order_number"></result>
   				<result property="createtime" column="createtime"></result>
   				<result property="note" column="note"></result>
   				<collection property="orderdetail" ofType="com.it.bean.OrderDetail">
					<!-- 订单明细 --> 
					<id property="id" column="orderdetail_id"/>
   					<result property="orders_id" column="order_id"/>
   					<result property="items_id" column="items_id"/>
   					<result property="items_num" column="items_num"/>  				
   					<association property="items" javaType="com.it.bean.Items">
   						<!-- 商品 -->
   						<id property="id" column="orderdetail_id"/>
   						<result property="name" column="items_name"/>
   						<result property="price" column="items_price"/>
   						<result property="pic" column="items_pic"/>
   						<result property="createtime" column="items_time"/>
   					</association>
   				</collection>
   			</collection>
   </resultMap>
   
   <select id="findUserAndItems" resultMap="findUserAndItemsMapping">
   	   SELECT  orders.*,
       us.username,us.usersex,us.useraddr,us.userbirth,
       ordd.id AS orderdetail_id,
       ordd.items_id,
       ordd.items_num,
       ordd.order_id as orders_id,
       it.name AS items_name,
       it.price AS items_price,
       it.pic AS items_pic,
       it.createtime AS items_time
       FROM  orderInfo orders,userInfo us,orderdetail ordd,items it
       WHERE orders.user_id=us.userid AND ordd.order_id=orders.order_id	and ordd.order_id=it.id
   </select>
   <!-- 多对多关联映射   结束-->
  
   
</mapper>
  • 测试类
package com.it.test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Before;
import org.junit.Test;

import com.it.bean.Order;
import com.it.bean.User;
import com.it.dao.StudentMapper;

public class TestMybatis {
	private InputStream is=null;
	private SqlSessionFactory sqlSessionFactory=null;
	private SqlSession sqlSession=null;
	private SqlSession sqlSession1=null;
	private StudentMapper studao=null;
	@Before
	public void before() throws IOException{
	   String resource="com/it/config/mybatis.xml";
	   is=Resources.getResourceAsStream(resource);
	   //创建会话工厂
	   sqlSessionFactory=new SqlSessionFactoryBuilder().build(is);
	   //通过工厂创建sqlsession
	   sqlSession=sqlSessionFactory.openSession();
	   sqlSession1=sqlSessionFactory.openSession();
	   studao=sqlSession.getMapper(StudentMapper.class);
	}
	
	@Test
	public void query(){
		List<Order> list=studao.findUserByOrders();
		System.out.println(list.size());
		for (Order order : list) {
			System.out.println(order.toString());
			//System.out.println(order.getUser().toString());
		}
		for (int i = 0; i <list.size(); i++) {
			System.out.println(list.get(i).getUser().toString());
		}
	}
	//延迟加载
	@Test
	public void findOrderDetailsByOrders(){
		List<Order> list=studao.findOrderDetailsByOrders();
		for (Order order : list) {
			System.out.println(order.toString());
		}
		System.out.println(list.size());
	}
	
	@Test
	public void aaa(){
		List<User> list=studao.findUserAndItems();
		for (User user : list) {
			System.out.println(user.toString());
		}
	}
	//延迟加载·
	@Test
	public void findOrder(){
		List<Order> list=studao.findOrder();
		for (Order order : list) {
			System.out.println(order.toString());
		}
		System.out.println(list.size());
	}
	//测试一级缓存
	@Test
	public void findUserById(){
		User user=studao.findUserById("10");
		System.out.println(user.getUsername());
		User user1=studao.findUserById("10");
		System.out.println(user1.getUsername());
	}
	//测试二级缓存
	@Test
	public void findUserById2(){
		User user=studao.findUserById("10");
		System.out.println(user.getUsername());
		sqlSession.close();
		
		StudentMapper studao1=sqlSession1.getMapper(StudentMapper.class);
		User user1=studao1.findUserById("10");
		System.out.println(user1.getUsername());
		
	}
	
	
	
		
}
狗老大
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MyBatis-Plus 的官方示例(mybatis-plus-samples-master.zip)
05-05
本工程为 MyBatis-Plus 的官方示例，项目结构如下： mybatis-plus-sample-quickstart: 快速开始示例 mybatis-plus-sample-quickstart-springmvc: 快速开始示例（Spring MVC版本） mybatis-plus-sample-reduce-...
【MyBatis框架】关联映射
一个真ikun
10-31 2498
讲解MyBatis框架对于复杂映射关系的处理，resaultMap等标签的使用。
【MyBatis框架】配置文件-resultMap总结
程序猿之洞
06-30 2111
resultMap总结 resultType： 作用： 将查询结果按照sql列名pojo属性名一致性映射到pojo中。 场合： 常见一些明细记录的展示，比如用户购买商品明细，将关联查询信息全部展示在页面时，此时可直接使用resultType将每一条记录映射到pojo中，在前端页面遍历list（list中是pojo）即可。 resultMap： 使用association和co
关联映射
每天都得进步一点点
09-18 1212
 关联映射 所谓关联映射即:即对象之间有引用关系。在数据库中如果要建立两张表的关联关系，就需要外键来连接它们，数据库表之间的关系是没有方向性的，彼此都是透明。而在java程序中如果要使两个类建立关系的话，那么就需要使用属性组合引用对方来产生关联，java程序中的关联是有方向性的，如果没有双向管理那么彼此是不透明的。   一对多、多对一（单向） 多对一:案列为User ---->Gro
MyBatis之关联映射解析
Wenqi's Blog
01-02 986
ORM框架一个重要的技术点是处理对象间的关联映射，比如一对一，一对多的关系，和Hibernate不同的是，Mybatis的使用需要开发人员直接和SQL语句进行打交道，所以在处理关联映射的时候不论是文件配置还是实现原理都是大有不同的，本文致力于使用一个例子讲清楚不同关联映射关系的配置和使用方法，以及作者在使用过程中对不同的参数的作用的深入理解。
认识Mybatis的关联关系映射，灵活关联表对象之间的关系
最新发布
SAME_LOVE的博客
08-26 1469
关联关系映射是指通过配置映射文件，将数据库中的关联表进行关联查询，并将查询结果映射到实体类的关联属性上。通过扩展关联关系映射，可以方便地进行复杂的数据库查询操作，提高查询效率和简化数据操作的代码。
mybatis-plus-code-generator-3.5.2.x.jar
03-09
MyBatis-Plus代码生成器
mybatis-spring-boot-starter-2.1.3.jar
01-10
mybatis-spring-boot-starter-2.1.3.jarmybatis-spring-boot-starter-2.1.3.jarmybatis-spring-boot-starter-2.1.3.jar
mybatis-plus-extension-3.4.0.jar
03-01
mybatis-plus-extension-3.4.0.jar
mybatis-3-mapper.rar
08-06
mybatis-3-mapper.dtd，解决eclipse使用mybatis时，无法自动提示标签信息的问题
第四章关联映射
NYLX9527的博客
06-04 332
|----认识关联映射: 介绍: 在以面向对象思想设计程序时,对象之间会产生关联引用.比如学生与班级,学生对象含有班级类型的属性,此时就会引用班级对象.将对象之间的关联关系映射到数据库,称为关联映射. 分析:[如何理解映射] ORM映射: 对象模型 数据库模型 对象 表 属性 字段 引用关系 表关系[外键字段] 关联映射的本质: 将对象与对象之间的引用,转为数据表与数据表之间的引用[通过外键实现] 备注: 无论哪种
Mybatis关联映射介绍及应用
qq_22075913的博客
09-22 368
Mybatis关联映射 一对一关联映射 一对多关联映射 多对多关联映射 1. 一对一关联映射 在现实生活中，一个人只能有一个身份证，一个身份证只能对应一个人，人和身份证之间就是一对一关系。以人和身份证为例，使用MyBatis框架处理它们之间的一对一关联关系的步骤如下所示。 实现步骤： 1）创建数据表person 和 idcard #创建数据表idcard create table idcard( id int PRIMARY key auto_increment, cno varchar(18) );
MyBatis关联映射(学习)
qq_42500186的博客
06-17 245
本文针对MyBatis的关联映射，重点在于： （1）不同的关联关系（一对一、一对多、多对多）如何创建数据表和在对应的类中创建外键关联。 （2）如何在各个类的xml映射文件中进行配置。 在xml映射文件中确定了什么方法，这些方法如何实现。 1、一对一关联映射 1.1数据表： tb_card 和 tb_person。 1.2数据表关联： 在tb_person表中新增一栏card_id，和tb_card...
mybatis关联映射的使用！一对一，一对多，多对一，多对多
小刘的博客
02-18 291
表的结构： 实体类部分代码： Wife类： public class Wife { private Integer id; private String name; private Integer userId; 。。。。。。。。。。。。。。。 } User类： public class User { private Integer id; ......
MyBatis学习_2_关联映射_一对一
l201013080的专栏
06-22 1153
今天学习的是mybatis的映射，这里比较重要的是resultMap，其实resultType背后就是通过resultMap将取出的字段自动映射到java bean的对应属性上的。所以resultMap就是对数据映射到java对象上的描述。 下面是我学习的例子：一个Blog类，一个Author类，一个Blog对应一个Author。 Blog定义如下： public class Blog {
MyBatis学习笔记--关联映射之一对一，一对多，多对多
weixin_44889138的博客
03-13 526
继续前一篇：https://blog.csdn.net/weixin_44889138/article/details/104731291 文章目录概述1. 一对一2. 一对多3. 多对多 概述 一对一：在任意一方引入对方主键作为外键。 一对多：在“多”的一方，添加“一”的一方的主键作为外键。 多对多：产生中间关系表，引入两张表的主键作为外键，两个主键成为联合主键或使用新的字段作为主键。 创建...
实现struts2与hibernate的整合
qq_40797063的博客
05-28 2612
主要思路 导入相关的jar包 web.xml中配置struts2拦截器 配置struts.xml文件 对应的action 配置hibernate.cfg.xml文件 配置映射文件*.hbm.xml文件 具体实现 工程目录结构 在pom.xml中导入想关的jar包 <!-- hibernate的和核心包 --> <dependency> ...
Struts2框架
qq_40797063的博客
05-27 515
1.struts框架 Struts是最早的Java开源框架之一，它是MVC设计模式的一个优秀实现。 Struts定义了通用的Controller（控制器），通过配置文件（通常是 Struts -config.xml） Struts是最早的java开源框架之一，它是MVC设计模式的一个优秀实现。 Struts定义了通用的Controller（控制器），通过配置文件（通常是 Struts -c...
Hibernate的入门使用
qq_40797063的博客
05-28 441
hibernate的来源 数据在各个层次之间流转，在流转过程中会发生数据类型转换等一系列的交互问题。java与html的交互解决方案是struts2提供的OGNL（对象导航图语言），而java与数据库之间的技术解决方案是ORM（对象关系映射）。 什么是ORM 对象关系映射：Object relation mapping 1.对象：指的是java对象，是实体bean 2.关系：关系只是数据库...
mybatis-plus-join关联查询
07-29
通过使用mybatis-plus-join，开发者可以更加方便地进行一对多和一对一映射查询。 #### 引用[.reference_title] - *1* *2* *3* [MybatisPlus多表连接查询](https://blog.csdn.net/bjdiys/article/details/130230405)...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值