Oracle，Mybatis框架例子，对正向映射和反向映射，反射和映射关系的理解【诗书画唱】

2021-03-12 19:15 作者:诗书画唱 0人读过 | 我要投稿

概括：

实现Mybatis框架的嵌套效果的关键

1、在mybatis项目中引入Log4j

2、实现客户（id,name,Sex）和地址(id,addr,cid)的正向映射和反向映射。

3、实现商品(id,name,price,typeId)和类型(id,tname)的正向映射和反向映射。

实现Mybatis框架的嵌套效果的关键 START

第一步：创建数据库的表，插入数据

其实映射就是代替了JDBC的功能，嵌套查询的话就是按自己的需求设置配置文件等等就可以。

实现Mybatis框架的嵌套效果的关键 END

作业 START

1、在mybatis项目中引入Log4j

2、实现客户（id,name,Sex）和地址(id,addr,cid)的正向映射和反向映射。

--drop table customer

create table customer(

id number primary key,

name varchar2(30) not null,

Sex varchar2(30) not null

);

--drop sequence seq_customer

create sequence seq_customer

start with 1 --起始值是1

increment by 1 --增长的值

maxvalue 999999999 --序列号的最大值

minvalue 1 --序列号的最小值

nocycle --是否循环

cache 10; --预存

insert into customer values(seq_customer.nextval,'A名字','男');

insert into customer values(seq_customer.nextval,'B名字','女');

insert into customer values(seq_customer.nextval,'C名字','男');

--select * from customer

--drop table address

create table address(

id number primary key,

addr varchar2(30) not null,

cid varchar2(30) not null

);

--drop sequence seq_address

create sequence seq_address

start with 1 --起始值是1

increment by 1 --增长的值

maxvalue 999999999 --序列号的最大值

minvalue 1 --序列号的最小值

nocycle --是否循环

cache 10; --预存

insert into address values(seq_address.nextval,'江西的收货地址',1);

insert into address values(seq_address.nextval,'广东的收货地址',2);

insert into address values(seq_address.nextval,'浙江的收货地址',3);

insert into address values(seq_address.nextval,'湖南的收货地址',1);

insert into address values(seq_address.nextval,'北京的收货地址',2);

insert into address values(seq_address.nextval,'上海的收货地址',3);

--select * from address

package com.SSHC.bean;

import java.util.List;

public class Address {

/*id,addr,cid*/

private Integer id;

private String addr;

private Integer cid;

/*下面的就是关联元素：

* （本来我是要命名为更有明确的意思的CustomerClass，

* 但是为了提高书写的效率的话，我就是会命名为简介的

* c（取头字母或2个字母的组合）*/

private Customer c;

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getAddr() {

return addr;

}

public void setAddr(String addr) {

this.addr = addr;

}

public Integer getCid() {

return cid;

}

public void setCid(Integer cid) {

this.cid = cid;

}

public Customer getC() {

return c;

}

public void setC(Customer c) {

this.c = c;

}

package com.SSHC.bean;

import java.util.ArrayList;

import java.util.List;

/*拥有可能多个所属“一”的“多”的“一”，这个部分就是要

*声明一个装着所属“一”的“多”的集合。

*个人理解："一”对“多”的关系就是主从关系。

*"一"就是"主"，"多"是"从"。*/

public class Customer {

private Integer id;

private String name;

private String Sex;

/*下面的元素（list）就是反向的关联元素：*/

private List<Address>list;

/*id number primary key,

name varchar2(30) not null,

Sex varchar2(30) not null*/

public Integer getId() {

return id;

}

public List<Address> getList() {

return list;

}

public void setList(List<Address> list) {

this.list = list;

}

public void setId(Integer id) {

this.id = id;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public String getSex() {

return Sex;

}

public void setSex(String Sex) {

this.Sex = Sex;

}

<?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">

<!-- 个人理解：习惯上property和column的值是要一样的，

前者是小写的Address中的要遍历出来的内容的列名，

后者是大写的。

要读取遍历出的列名就是要使用result标签遍历出来。

association中一般是property=

"当前xml文件对应的实体类中命名的属性名"

column="当前xml文件对应的实体类中命名的编号的命名"

-->

<association property="c" column="CID"

select="com.SSHC.dao.CustomerDao.selectById">

</association>

<!-- 个人的理解：association就是关联的元素，

所以这个部分的内容是必不可少的。

property：性质。

大家发现了吗?其实

property的值都是和bean包下的Address中的属性名对应的，

column为大写的属性名。

result标签的属性取值都是当前xml文件相关的bean包下的实体类

的属性名。

-->

</resultMap>

select * from Address where cid = #{cid}

</select>

select * from Address

</select>

</mapper>

<?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">

<!-- 映射文件部分的配置 START

property指的就是Customer属性中的关系属性名

javaType指的就是plist的类型是一个ArrayList

column指的就是商品类型id取自Customer表中的哪个列

ofType指的就是plist中存放的对象类型

select指的就是需要执行的查询语句-->

<!-- 其实column就是对应的当前的表的列名，

如果你在Oracle中查看表的数据的话就是会发现

，你建表是小写的列名，但是

oracl查询出来时的列名全部是大写的。

property和column是对应的关系，

就是Java的实体类中的属性和数据库中对应的列名的关系。

ofType="Address"其实我有时理解为

要数据库中查询的类型是Address表中的内容

-->

<collection property="list" javaType="ArrayList"

column="ID"

ofType="Address"

select="com.SSHC.dao.AddressDao.selectById">

</collection>

</resultMap>

select * from Customer

</select>

select * from Customer where id= #{id}

</select>

</mapper>

/** CTRL+F:

* 在使用Mybatis框架前要用的JDBC的代码，使用Mybatis框架后

就不必使用

下面的内容是通过for的嵌套的遍历打印出

2个表的内容

* */

package ZSGC;

import java.io.IOException;

import java.io.Reader;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import java.util.Scanner;

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 com.SSHC.bean.Address;

import com.SSHC.bean.Customer;

import com.SSHC.bean.Userinfo;

public class CustomerAddressTest {

public static void main(String[] args) {

// TODO Auto-generated method stub

//为了获取主配置文件的路径而去声明一个path的变量：

String path = "mybatis.xml";

//读取mybatis.xml中的配置信息，就是读取四大连接字符串的内容：

Reader config;

try {

config = Resources.getResourceAsReader(path);

SqlSessionFactory factory =

new SqlSessionFactoryBuilder().build(config);

//数据库的操作对象session（这个是自己命名的）：

SqlSession session = factory.openSession();

//调用selectAll

//执行路径就是映射文件的namespace属性+'.'+id

/**下面的内容是通过for的嵌套的遍历打印出

2个表的内容 START */

String exePath = null;

/*一个人可以对应多个地址（比如快递中的运用，

就像是一个商品类型可以

对应多个商品。进行一些类比的运用。*/

exePath = "com.SSHC.dao.CustomerDao.selectAll";

List<Customer>ls = session.selectList(exePath);

for(Customer c : ls){

System.out.println(c.getName());

/*先打印出“一”的属性，但其实按自己的需求来。*/

List<Address>list = c.getList();

for(Address p : list) {

System.out.println(p.getAddr());

/*后面的话就是打印出“多”的属性。

* */

}

/**下面的内容是通过for的嵌套的遍历打印出

2个表的内容 END */

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

oracle_drivername=oracle.jdbc.driver.OracleDriver

oracle_url=jdbc:oracle:thin:@localhost:1521:orcl

oracle_username=X

oracle_password=sshcPwd

mysql_drivername=com.mysql.jdbc.Driver

mysql_url=jdbc:mysql://localhost:3306/j190802?useUnicode=true&characterEncoding=GBK2312

mysql_username=root

mysql_password=1

sqlserver_drivername=com.microsoft.sqlserver.jdbc.SQLServerDriver

sqlserver_url=jdbc:sqlserver://localhost:1433;databaseName=cervs

sqlserver_username=sa

sqlserver_password=

log4j.rootLogger=DEBUG,Console

#Console

log4j.appender.Console=org.apache.log4j.ConsoleAppender

log4j.appender.Console.layout=org.apache.log4j.PatternLayout

log4j.appender.Console.layout.ConversionPattern=%d[%t] %-5p [%c] - %m%n

log4j.logger.java.sql.ResultSet=INFO

log4j.logger.org.apache=INFO

log4j.logger.java.sql.Connection=DEBUG

log4j.logger.java.sql.Statement=DEBUG

log4j.logger.java.sql.PreparedStatement=DEBUG

<?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">

</typeAliases>

</transactionManager>

</dataSource>

</environment>

</transactionManager>

</dataSource>

</environment>

</environments>

</mappers>

</configuration>

3、实现商品(id,name,price,typeId)和类型(id,tname)的正向映射和反向映射。

--drop table Product

create table Product(

id number primary key,

pname varchar2(30) not null,

price number(10,2),

ptype number

);

--drop sequence seq_Product

create sequence seq_Product

start with 1 --起始值是1

increment by 1 --增长的值

maxvalue 999999999 --序列号的最大值

minvalue 1 --序列号的最小值

nocycle --是否循环

cache 10; --预存

insert into Product values(seq_Product.nextval,'黑笔',1.5,1);

insert into Product values(seq_Product.nextval,'红书',2.0,2);

insert into Product values(seq_Product.nextval,'挂面',3.0,3);

insert into Product values(seq_Product.nextval,'蓝笔',1.5,1);

insert into Product values(seq_Product.nextval,'黄书',2.0,2);

insert into Product values(seq_Product.nextval,'拉面',3.0,3);

--select * from Product

--drop table Protype

create table Protype(

id number primary key,

tname varchar2(30) not null

);

--drop sequence seq_Protype

create sequence seq_Protype

start with 1 --起始值是1

increment by 1 --增长的值

maxvalue 999999999 --序列号的最大值

minvalue 1 --序列号的最小值

nocycle --是否循环

cache 10; --预存

insert into Protype values(seq_Protype.nextval,'笔');

insert into Protype values(seq_Protype.nextval,'书');

insert into Protype values(seq_Protype.nextval,'面');

--select * from Protype

package com.SSHC.bean;

//一对多中的一：

public class Product {

private Integer id;

private String pname;

private Double price;

private Integer ptype;

/*pt就是关联属性（数据库没pt这一列）：

也就是声明了另一个类，一般是在作为“一”的对象中，声明出

作为“多”的对象这个类。pt就是ptype的缩写，如果不熟的话就是

命名具体一些，如果很熟了就简短有意义的命名。*/

private Protype pt;

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getPname() {

return pname;

}

public void setPname(String pname) {

this.pname = pname;

}

public Double getPrice() {

return price;

}

public void setPrice(Double price) {

this.price = price;

}

public Integer getPtype() {

return ptype;

}

public void setPtype(Integer ptype) {

this.ptype = ptype;

}

public Protype getPt() {

return pt;

}

public void setPt(Protype pt) {

this.pt = pt;

}

package com.SSHC.bean;

import java.util.List;

public class Protype {

private Integer id;

private String tname;

//反向关联属性

private List<Product>plist;

public Integer getId() {

return id;

}

public void setId(Integer id) {

this.id = id;

}

public String getTname() {

return tname;

}

public void setTname(String tname) {

this.tname = tname;

}

public List<Product> getPlist() {

return plist;

}

public void setPlist(List<Product> plist) {

this.plist = plist;

}

<?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">

<!--

property就是指的Product对应的唯一的商品类型对象

column就是指从Product表中查询的商品类型id取自Product表的哪个列

select就是指需要执行的商品类型的查询语句

-->

<association property="pt" column="PTYPE"

select="com.SSHC.dao.ProtypeDao.selectById" >

</association>

</resultMap>

select * from product

</select>

select * from product where ptype = #{tid}

</select>

</mapper>

<?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">

<!--

property就是指的Product对应的唯一的商品类型对象

column就是指从Product表中查询的商品类型id取自Product表的哪个列

select就是指需要执行的商品类型的查询语句

-->

<association property="pt" column="PTYPE"

select="com.SSHC.dao.ProtypeDao.selectById" >

</association>

</resultMap>

select * from product

</select>

select * from product where ptype = #{tid}

</select>

</mapper>

/** CTRL+F:

* 在使用Mybatis框架前要用的JDBC的代码，使用Mybatis框架后

就不必使用

下面的内容是通过for的嵌套的遍历打印出

2个表的内容

* */

package ZSGC;

import java.io.IOException;

import java.io.Reader;

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.ArrayList;

import java.util.List;

import java.util.Scanner;

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 com.SSHC.bean.Product;

import com.SSHC.bean.Protype;

import com.SSHC.bean.Userinfo;

public class Test {

public static void main(String[] args) {

// TODO Auto-generated method stub

/** 在使用Mybatis框架前要用的JDBC的代码，使用Mybatis框架后

就不必使用 START*/

// String drivername = "oracle.jdbc.driver.OracleDriver";

// //oracle数据库的默认端口号1521

// //连接的数据库名字是orcl数据库

// String url = "jdbc:oracle:thin:@localhost:1521:orcl";

// String username = "j190802";

// String pwd = "orcl";

// Connection conn = null;

// PreparedStatement pstm = null;

// ResultSet rs = null;

// try {

// Class.forName(drivername);

// conn = DriverManager.getConnection(url,username,pwd);

// pstm = conn.prepareStatement("select * from userinfo where id = ?");

// pstm.setInt(1, 8);

// rs = pstm.executeQuery();

// List<Userinfo>rmUserinfo = new ArrayList<Userinfo>();

// while(rs.next()) {

// Userinfo u = new Userinfo();

// //ID是userinfo表的主键

// u.setId(rs.getInt("ID"));

// u.setAct(rs.getString("ACT"));

// System.out.println(rs.getString("ACT"));

// u.setPwd(rs.getString("PWD"));

// u.setBirth(rs.getString("BIRTH"));

// rmUserinfo.add(u);

// }

// String sql = "insert into userinfo values(?,?,?,to_date(?,'yyyy-mm-dd'))";

// pstm = conn.prepareStatement(sql);

// Userinfo u = new Userinfo();

// u.setId(11);

// u.setAct("haha");

// u.setPwd("09876");

// u.setBirth("2000-7-3");

// pstm.setInt(1, u.getId());

// pstm.setString(2, u.getAct());

// pstm.setString(3, u.getPwd());

// pstm.setString(4, u.getBirth());

// int count = pstm.executeUpdate();

// System.out.println(count);

// } catch (Exception e) {

// // TODO Auto-generated catch block

// e.printStackTrace();

// } finally {

// try {

// if(rs != null) {

// rs.close();

// }

// if(pstm != null) {

// pstm.close();

// }

// if(conn != null) {

// conn.close();

// }

// } catch(Exception e) {

// e.printStackTrace();

// }

/** 在使用Mybatis框架前要用的JDBC的代码，使用Mybatis框架后

就不必使用 END*/

//为了获取主配置文件的路径而去声明一个path的变量：

String path = "mybatis.xml";

//读取mybatis.xml中的配置信息，就是读取四大连接字符串的内容：

Reader config;

try {

config = Resources.getResourceAsReader(path);

SqlSessionFactory factory =

new SqlSessionFactoryBuilder().build(config);

//数据库的操作对象session（这个是自己命名的）：

SqlSession session = factory.openSession();

//调用selectAll

//执行路径就是映射文件的namespace属性+'.'+id

while(true){

System.out.print("请选择操作：1.查询"

+ "Userinfo表的所有内容 "

+ ",2.查询ProductDao表的所有内容,"

+ "\n 3.嵌套查询,"

+ "4.UserinfoDao的id查询,"

+ "\n"

+ "5.Oracle中的UserinfoDao表的运用序列的新增,"

+ "\n 6.MySQL中的UserinfoDao表的运用自增的新增 ,"

+ "\n 7.UserinfoDao表的修改,"

+ "\n8.根据ID删除UserinfoDao表的内容");

Scanner input = new Scanner(System.in);

int num = input.nextInt();

System.out.println(num);

String exePath = null;

if(num==1){

exePath = "com.SSHC.dao.UserinfoDao.selectAll";

List<Userinfo>list = session.selectList(exePath);

for(Userinfo u : list) {

System.out.println(u.getId()+" "+u.getAct()+" "+u.getBirth()

+" "+u.getPwd());

}

if(num==2){

exePath = "com.SSHC.dao.ProductDao.selectAll";

List<Product>lt = session.selectList(exePath);

for(Product p : lt) {

System.out.println(p.getPname());

Integer ptype = p.getPtype();

//还要进行一次查询才可以将商品类型中文名称查询出来

// Protype pt = session

// .selectOne("com.SSHC.dao.ProtypeDao.selectById",ptype);

// System.out.println(pt.getTname());

System.out.println(p.getPt().getTname());

}

if(num==3){

/**下面的内容是通过for的嵌套的遍历打印出

2个表的内容 START */

exePath = "com.SSHC.dao.ProtypeDao.selectAll";

List<Protype>ls = session.selectList(exePath);

for(Protype pt : ls){

System.out.println(pt.getTname());

/*先打印出“多”的关系的部分*/

List<Product>plist = pt.getPlist();

/*再打印出“多”的关系的部分中声明的装着

* 所属的“一”的部分：*/

for(Product p : plist) {

System.out.println(p.getPname());

}

/**下面的内容是通过for的嵌套的遍历打印出

2个表的内容 END */

}

if(num==4){

exePath = "com.SSHC.dao.UserinfoDao.selectById";

Userinfo u = session.selectOne(exePath,1);

System.out.println(u.getAct());

}

if(num==5){

exePath = "com.SSHC.dao.UserinfoDao.add";

Userinfo u = new Userinfo();

u.setAct("诗书画唱");

u.setPwd("999");

u.setBirth("2009-9-20");

Integer count = session.insert(exePath,u);

//新增修改和删除一定记得提交事务

session.commit();

System.out.println(count);

}

if(num==6){

exePath = "com.SSHC.dao.UserinfoDao.addMySQL";

Userinfo u = new Userinfo();

u.setAct("诗书画唱");

u.setPwd("666");

u.setBirth("1999-7-7");

Integer count = session.insert(exePath,u);

//新增修改和删除一定记得提交事务

session.commit();

System.out.println(count);

}

if(num==7){

Userinfo u = new Userinfo();

u.setId(11);

u.setAct("测试账号");

u.setPwd("555555");

u.setBirth("1998-11-29");

exePath = "com.SSHC.dao.UserinfoDao.update";

Integer count = session.update(exePath,u);

//新增修改和删除一定记得提交事务

session.commit();

System.out.println(count);

}

if(num==8){

exePath = "com.SSHC.dao.UserinfoDao.deleteById";

Integer count = session.delete(exePath,8);

//新增修改和删除一定记得提交事务

session.commit();

System.out.println(count);

}

}} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

作业 END

个人对正向映射和反向映射，反射和映射的关系的理解 START

在一实体类A中声明另一个实体类B就是正向映射。

在B实体类中声明A实体类为集合的泛型的ArrayList等集合就是反向映射。

怎么区分正向映射和反向映射？其实2者是相对的关系。行业习惯上规定在一实体类A中声明另一个实体类B就是正向映射，相对的，在B实体类中声明A实体类为集合的泛型的ArrayList等集合就是反向映射。

反射和映射的关系很大，其实映射是Mybatis框架中使用的技术，而映射技术是在反射技术的基础上产生的（这些内容是我目前个人的理解，可能有不准确的地方）。

映射可以减少JDBC代码和Dao的部分。

个人对正向映射和反向映射，反射和映射的关系的理解 END

标签：

Oracle，Mybatis框架例子，对正向映射和反向映射，反射和映射关系的理解【诗书画唱】

实现Mybatis框架的嵌套效果的关键 START

实现Mybatis框架的嵌套效果的关键 END

作业 START

作业 END

个人对正向映射和反向映射，反射和映射的关系的理解 START

个人对正向映射和反向映射，反射和映射的关系的理解 END