一、SSM：Spring / Spring MVC / Mybatis
--------------------------------------------------------------------------
1.java web 的一套框架
2.Spring:业务层框架
3.Spring MVC：开发web程序应用的模块 -- model view controller
4.Mybatis：数据持久化技术。jdbc操作mysql，对数据进行持久化存储
二、Mybatis:对jdbc的封装
-------------------------------------------------------------------------
1.创建项目和模块
2.添加pom依赖
<dependencies>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>3.2.1</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.17</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
</dependency>
</dependencies>
3.创建配置文件
[resoucecs/mybatis-config.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>
<environments default="development">
<environment id="development">
<transactionManager type="JDBC"/>
<dataSource type="POOLED">
<property name="driver" value="com.mysql.jdbc.Driver"/>
<property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
<property name="username" value="mysql"/>
<property name="password" value="mysql"/>
</dataSource>
</environment>
</environments>
<mappers>
<!-- 这里添加自定义的mapper映射xml文件 -->
</mappers>
</configuration>
4.在mysql中创建数据库mybatis和表mybatis.users
$mysql> create database mybatis;
$mysql> create table mybatis.users (id int primary key auto_increment, name varchar(20), age int);
5.测试是否连通
--------------------------------
package test.ssm;
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 java.io.InputStream;
/**
* 测试mybatis
*/
public class TestMybatis {
public static void main(String [] args)
{
try {
//指定配置文件的路径(类路径)
String resource = "mybatis-config.xml";
//加载文件
InputStream inputStream = Resources.getResourceAsStream(resource);
//创建会话工厂Builder,相当于连接池
SqlSessionFactory sf = new SqlSessionFactoryBuilder().build(inputStream);
//通过sf开启会话，相当于打开连接。
SqlSession s = sf.openSession();
System.out.println(s);
} catch (Exception e) {
e.printStackTrace();
}
}
}
6.编写mapper文件
a.创建用户类users -- 和用户表对应
/**
* 与数据库中的表users对应
*/
public class Users {
private int id;
private String name;
private int age;
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 int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
b.创建UserMapper.xml映射文件,存放在resources/目录下,将表与类对应起来
[resources/UserMapper.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="user">
<insert id="insert">
<!--#{name},#{age} 表示参数，占位符-->
insert into users (name,age) values (#{name},#{age});
</insert>
</mapper>
7.在resources/mybatis-config.xml文件中引入mapper的xml文件
...
<mappers>
<mapper resource="UserMapper.xml"/>
</mappers>
8.编写单元测试，实现mapper文件中的插入操作
/**
* insert
*/
@Test
public void insert() throws Exception {
//指定配置文件的路径(类路径)
String resource = "mybatis-config.xml";
//加载文件
InputStream inputStream = Resources.getResourceAsStream(resource);
//创建会话工厂Builder,相当于连接池
SqlSessionFactory sf = new SqlSessionFactoryBuilder().build(inputStream);
//通过sf开启会话，相当于打开连接。
SqlSession s = sf.openSession();
User u = new User();
u.setName("jerry");
u.setAge(2);
s.insert("users.insert", u);
s.commit();
s.close();
}
9.测试CRUD操作
a.编写mapper映射文件UserMapper.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="users">
<insert id="insert">
<!--#{name},#{age} 表示参数，占位符-->
insert into users (name,age) values (#{name},#{age});
</insert>
<update id="update1">
update users set name = #{name} ,age = #{age} where id = #{id};
</update>
<!-- 查询一个 注意查询要指定结果的类型-->
<select id="select_one" parameterType="int" resultType="test.ssm.domain.Users">
select * from users where id = #{id};
</select>
<!-- 查询多个 注意查询要指定结果的类型-->
<select id="select_all" resultType="test.ssm.domain.Users">
select * from users;
</select>
<delete id="delete">
delete from users where id = #{id};
</delete>
</mapper>
b.编写单元测试进行CRUD
----------------------------------
package test.ssm;
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 test.ssm.domain.Users;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
/**
* 测试增删改查
*/
public class TestCRUD {
private SqlSession session = null;
/**
* 打开sql会话
*/
@Before
public void getSqlSession() throws Exception {
//指定配置文件的路径(类路径)
String resource = "mybatis-config.xml";
//加载文件
InputStream inputStream = Resources.getResourceAsStream(resource);
//创建会话工厂Builder,相当于连接池
SqlSessionFactory sf = new SqlSessionFactoryBuilder().build(inputStream);
//通过sf开启会话，相当于打开连接。
session = sf.openSession();
}
/**
* 测试插入
*/
@Test
public void tsInsert()
{
Users u = new Users();
u.setName("jerry111");
u.setAge(3);
//找到插入语句所在的mapper文件[namespace.insert id]
session.insert("users.insert", u);
session.commit();
session.close();
}
/**
* 测试更新
*/
@Test
public void tsUpdate()
{
Users u = new Users();
u.setName("jerry11");
u.setAge(13);
u.setId(1);
//找到插入语句所在的mapper文件[namespace.insert id]
session.update("users.update1",u);
session.commit();
session.close();
}
/**
* 测试查询 -- 查询一个
*/
@Test
public void tsSelectOne()
{
Users u = new Users();
u.setId(1);
//找到插入语句所在的mapper文件[namespace.insert id]
u = session.selectOne("users.select_one",u);
System.out.println(u.getAge() + ":" + u.getName());
session.close();
}
/**
* 测试查询 -- 查询全部
*/
@Test
public void tsSelectAll()
{
List<Users> list = session.selectList("users.select_all");
for(Users u : list)
{
System.out.println(u.getAge() + ":" + u.getName());
}
session.close();
}
/**
* 测试删除
*/
@Test
public void tsDelete()
{
Users u = new Users();
u.setId(1);
session.delete("users.delete", u);
session.commit();
session.close();
}
}
三、复杂关系访问-- 关联查询订单[多对一]
-------------------------------------------------
1.准备数据库[d:\\sql.sql]
use mybatis ;
-- 删除表
drop table if exists items ;
drop table if exists orders ;
drop table if exists users ;
-- 创建表
create table users(id int primary key auto_increment , name varchar(20) , age int);
create table orders(id int primary key auto_increment , orderno varchar(20) , uid int);
create table items(id int primary key auto_increment , itemname varchar(20) , oid int);
-- 插入用户
insert into users(name,age) values('tom',12);
insert into users(name,age) values('tomas',13);
-- 插入订单
insert into orders(orderno,uid) values('No001',1);
insert into orders(orderno,uid) values('No002',1);
insert into orders(orderno,uid) values('No003',2);
insert into orders(orderno,uid) values('No004',2);
-- 插入订单项
insert into items(itemname,oid) values('item001',1);
insert into items(itemname,oid) values('item002',1);
insert into items(itemname,oid) values('item003',2);
insert into items(itemname,oid) values('item004',2);
insert into items(itemname,oid) values('item005',3);
insert into items(itemname,oid) values('item006',3);
insert into items(itemname,oid) values('item007',4);
insert into items(itemname,oid) values('item008',5);
select * from users ;
select * from orders ;
select * from items ;
2.执行sql.sql文件
$mysql> source d:\\sql.sql;
3.java项目中创建类users/orders/items
--------------------------------------------
public class Users {
private int id;
private String name;
private int age;
//getter
//setter
}
public class Orders {
private int id;
private String orderno;
private Users user;
//geter
//setter
}
public class Items {
private int id;
private String itemname;
private Orders order;
//getter
//setter
}
4.创建订单映射文件 Resources/OrderMapper.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="orders">
<insert id="insert">
insert into orders (orderno,uid) values (#{orderno},#{user.id});
</insert>
<select id="select_by_id" parameterType="int" resultType="test.ssm.domain.Orders">
select * from orders where id = #{id};
</select>
<!-- 关联查询：左外连接查询 -->
<select id="select_join_one" parameterType="int" resultMap="MyResMap">
select
o.id oid ,
o.orderno ono,
o.uid uid,
u.name uname,
u.age uage
from orders o
left outer join users u
on o.uid=u.id
where o.id= #{id};
</select>
<!-- 关联查询：左外连接查询 -->
<select id="select_join_all" parameterType="int" resultMap="MyResMap">
select
o.id oid ,
o.orderno ono,
o.uid uid,
u.name uname,
u.age uage
from orders o
left outer join users u
on o.uid=u.id;
</select>
<!-- 指定：关联查询别名的映射 将类的属性与表中列的别名进行映射-->
<resultMap id="MyResMap" type="test.ssm.domain.Orders">
<!-- 主键用id ,其余用 result -->
<id property="id" column="oid"/>
<result property="orderno" column="ono"/>
<!-- 关联的类要特殊处理，如下 -->
<association property="user" javaType="test.ssm.domain.Users">
<id property="id" column="uid"/>
<result property="name" column="uname"/>
<result property="age" column="uage"/>
</association>
</resultMap>
</mapper>
5.将订单映射文件关联到mybatis-config.xml中
...
<mappers>
<mapper resource="UserMapper.xml"/>
<mapper resource="OrderMapper.xml"/>
</mappers>
6.测试操作订单
---------------------------
package test.ssm;
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 test.ssm.domain.Orders;
import test.ssm.domain.Users;
import java.io.InputStream;
import java.util.List;
/**
* 测试联合查询
*/
public class TestOrders {
private SqlSession session = null;
/**
* 打开sql会话
*/
@Before
public void getSqlSession() throws Exception {
//指定配置文件的路径(类路径)
String resource = "mybatis-config.xml";
//加载文件
InputStream inputStream = Resources.getResourceAsStream(resource);
//创建会话工厂Builder,相当于连接池
SqlSessionFactory sf = new SqlSessionFactoryBuilder().build(inputStream);
//通过sf开启会话，相当于打开连接。
session = sf.openSession();
}
/**
* 测试插入数据--关联users
*/
@Test
public void tsOrderInsert()
{
Users user = new Users();
user.setId(2);
Orders order = new Orders();
order.setOrderno("No005");
order.setUser(user);
session.insert("orders.insert", order);
session.commit();
session.close();
}
/**
* 测试id查询
*/
@Test
public void tsSelectById()
{
Orders order = new Orders();
order.setId(3);
order = session.selectOne("orders.select_by_id", order);
session.close();
System.out.println(order.getOrderno());
}
/**
* 测试关联查询 -- 左外连接查询
* 查询订单的同时，查询出订单的客户信息
* select o.id oid , o.orderno ono, o.uid uid, u.name uname, u.age uage from orders o left outer join users u on o.uid=u.id where o.id=1;
*/
@Test
public void tsJoinSelectOne()
{
Orders order = session.selectOne("orders.select_join_one", 1);
System.out.println(order.getUser().getName() + order.getOrderno());
session.close();
}
/**
* 测试关联查询 -- 左外连接查询
* 查询订单的同时，查询出订单的客户信息
* select o.id oid , o.orderno ono, o.uid uid, u.name uname, u.age uage from orders o left outer join users u on o.uid=u.id;
*/
@Test
public void tsJoinSelectAll()
{
List<Orders> list = session.selectList("orders.select_join_all");
for(Orders o : list)
{
System.out.println(o.getId()+ "_" + o.getOrderno() + "_" + o.getUser().getId() + "_" + o.getUser().getName() + "_" + o.getUser().getAge());
}
session.close();
}
}
四、复杂关系访问-- 组合多对一和一对多关联关系到一个实体(Order)中
-----------------------------------------------------------------------
1.在用户类Users中添加一个order的集合属性
...
private List<Orders> list = new ArrayList<Orders>();
...
2.在订单类Orders中添加一个Items的集合属性
...
private List<Items> itemList = new ArrayList<Items>();
...
3.修改mybatis-config.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>
<!-- 给类定义别名 -->
<typeAliases>
<typeAlias type="test.ssm.domain.Orders" alias="_Orders"/>
<typeAlias type="test.ssm.domain.Users" alias="_Users"/>
<typeAlias type="test.ssm.domain.Items" alias="_Items"/>
</typeAliases>
<environments default="development">
...
</environments>
<mappers>
...
</mappers>
</configuration>
4.修改用户映射文件 [Resources/UserMapper.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="users">
<insert id="insert">
<!--#{name},#{age} 表示参数，占位符-->
insert into users (name,age) values (#{name},#{age});
</insert>
<update id="update1">
update users set name = #{name} ,age = #{age} where id = #{id};
</update>
<!-- 查询一个 注意查询要指定结果的类型-->
<select id="select_one" parameterType="int" resultType="_Users">
select * from users where id = #{id};
</select>
<!-- 查询多个 注意查询要指定结果的类型-->
<select id="select_all" resultType="_Users">
select * from users;
</select>
<delete id="delete">
delete from users where id = #{id};
</delete>
<select id="select_join_one" parameterType="int" resultMap="userMap">
select
u.id uid,
u.name uname,
u.age uage,
o.id oid,
o.orderno ono
from users u
left outer join orders o
on u.id = o.uid
where u.id = #{id};
</select>
<select id="select_join_all" resultMap="userMap">
select
u.id uid,
u.name uname,
u.age uage,
o.id oid,
o.orderno ono
from users u
left outer join orders o
on u.id = o.uid;
</select>
<!-- 别名映射 将类中的属性名与表的列明或者列的别名进行映射 -->
<resultMap id="userMap" type="_Users">
<id property="id" column="uid"/>
<result property="name" column="uname"/>
<result property="age" column="uage"/>
<!-- Users中的属性 List<Orders> list 的表示方式 -->
<!-- property 表示属性名称 foType表示集合中的元素的类型 -->
<collection property="list" ofType="_Orders">
<id property="id" column="oid"/>
<result property="orderno" column="ono"/>
</collection>
</resultMap>
</mapper>
5.测试操作用户进行关联订单查询
---------------------------
package test.ssm;
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 test.ssm.domain.Orders;
import test.ssm.domain.Users;
import java.io.InputStream;
import java.util.List;
/**
* 测试联合查询
*/
public class TestUsers {
private SqlSession session = null;
/**
* 打开sql会话
*/
@Before
public void getSqlSession() throws Exception {
//指定配置文件的路径(类路径)
String resource = "mybatis-config.xml";
//加载文件
InputStream inputStream = Resources.getResourceAsStream(resource);
//创建会话工厂Builder,相当于连接池
SqlSessionFactory sf = new SqlSessionFactoryBuilder().build(inputStream);
//通过sf开启会话，相当于打开连接。
session = sf.openSession();
}
/**
* 测试关联查询 -- 左外连接查询
*/
@Test
public void tsJoinSelectOne()
{
Users user = session.selectOne("users.select_join_one", 1);
List<Orders> list = user.getList();
for(Orders o : list)
{
System.out.println(user.getId() + ":" + user.getName() + ":" + user.getAge() + ":" + o.getId() + ":" + o.getOrderno());
}
session.close();
}
/**
* 测试关联查询 -- 左外连接查询
*/
@Test
public void tsJoinSelectAll()
{
List<Users> usersList = session.selectList("users.select_join_all");
for(Users user : usersList)
{
List<Orders> list = user.getList();
for(Orders o : list)
{
System.out.println(user.getId() + ":" + user.getName() + ":" + user.getAge() + ":" + o.getId() + ":" + o.getOrderno());
}
}
session.close();
}
}
6.修改Order映射文件 [Resources/OrderMapper.xml] -- 进行用户订单item三级关联查询
<!-- 三级关联查询：用户-订单-items -->
<select id="select_join_3_one" parameterType="int" resultMap="MyResMap">
select
o.id oid ,
o.orderno ono,
o.uid uid,
u.name uname,
u.age uage,
i.id iid,
i.itemname iitemname
from orders o
left outer join users u on o.uid=u.id
left outer join items i on o.id = i.oid
where o.id = #{id};
</select>
<!-- 三级关联查询：用户-订单-items -->
<select id="select_join_3_all" resultMap="MyResMap">
select
o.id oid ,
o.orderno ono,
o.uid uid,
u.name uname,
u.age uage,
i.id iid,
i.itemname iitemname
from orders o
left outer join users u on o.uid=u.id
left outer join items i on o.id = i.oid;
</select>
<!-- 指定：关联查询别名的映射 将类的属性与表中列的别名进行映射-->
<resultMap id="MyResMap" type="test.ssm.domain.Orders">
<!-- 主键用id ,其余用 result -->
<id property="id" column="oid"/>
<result property="orderno" column="ono"/>
<!-- 关联的类要特殊处理，如下 -->
<association property="user" javaType="test.ssm.domain.Users">
<id property="id" column="uid"/>
<result property="name" column="uname"/>
<result property="age" column="uage"/>
</association>
<!-- 处理集合属性 -->
<collection property="itemList" ofType="_Items">
<id property="id" column="iid"/>
<result property="itemname" column="iitemname"/>
</collection>
</resultMap>
7.修改Orders类,测试3级关联查询
----------------------------------------
/**
* 测试3级查询--指定id
*/
@Test
public void tsJoinSelectOne_3()
{
Orders o = session.selectOne("orders.select_join_3_one", 1);
List<Items> list = o.getItemList();
for(Items i : list)
{
System.out.println(
o.getId() + "_" + o.getOrderno() + "_"
+ o.getUser().getId() + "_" + o.getUser().getName() + "_" + o.getUser().getAge() + "_"
+ i.getId() + "_" + i.getItemname()
);
}
session.close();
}
/**
* 测试3级查询--全查询
*/
@Test
public void tsJoinSelectAll_3()
{
List<Orders> oList = session.selectList("orders.select_join_3_all");
for(Orders o : oList)
{
List<Items> list = o.getItemList();
for(Items i : list)
{
System.out.println(
o.getId() + "_" + o.getOrderno() + "_"
+ o.getUser().getId() + "_" + o.getUser().getName() + "_" + o.getUser().getAge() + "_"
+ i.getId() + "_" + i.getItemname()
);
}
}
session.close();
}
五、项目的规范化改造
-------------------------------------------------
1.在生产环境中，一般将CRUD的操作封装到一个类中，一般叫做Dao[data access object]
2.增删改这样的代码，只需要更改很少的内容，其余完全一样。这种情况，考虑使用模板代码DaoTemplate
3.编写模板类dao.DaoTemplate[抽取共性，并且将不同的地方写入到一个独立的回调接口ICallBack]
-------------------------------------
package dao;
import org.apache.ibatis.session.SqlSession;
import test.ssm.domain.Users;
import util.Util;
/**
* CRUD模板代码
* 增删改这样的代码，只需要更改很少的内容，其余完全一样。
* 这种情况，考虑使用模板代码DaoTemplate
*/
public class DaoTemplate {
/**
* 模板方法
*/
public static Object execute(ICallBack cb)
{
SqlSession session = null;
try{
session = Util.openSqlSession();
Object obj = cb.exeSession(session);
session.commit();
return obj;
}
catch(Exception e)
{
e.printStackTrace();
//如果出现了错误就回滚
Util.rollbackSqlSession(session);
}
finally {
//最终确保session关闭
Util.closeSqlSession(session);
}
return null;
}
}
4.编写回调接口，用于管理变化的那部分代码[模板类处理相同的代码，回调接口处理变化的那部分代码，谁调用，谁制定接口方法]
-------------------------------------
package dao;
import org.apache.ibatis.session.SqlSession;
public interface ICallBack {
public Object exeSession(SqlSession s);
}
5.编写实际的类UserDao类，用于用户的增删改查[因为调用了DaoTemplate.execute的模板方法，所以需要根据情况重写回调接口的回调方法]
----------------------------------
package dao;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import test.ssm.domain.Orders;
import test.ssm.domain.Users;
import util.Util;
import java.util.List;
/**
* 用户dao类，用于users表的增删改查
*/
public class UserDao {
/**
* 增
*/
public void insert(final Users user)
{
DaoTemplate.execute(new ICallBack() {
public Object exeSession(SqlSession s) {
s.insert("users.insert",user);
return null;
}
});
}
/**
* 删
*/
public void delete(final Users user)
{
DaoTemplate.execute(new ICallBack() {
public Object exeSession(SqlSession s) {
s.insert("users.delete",user);
return null;
}
});
}
/**
* 改
*/
public void update(final Users user)
{
DaoTemplate.execute(new ICallBack() {
public Object exeSession(SqlSession s) {
s.insert("users.update",user);
return null;
}
});
}
/**
* 测试查询
*/
@Test
public Users tsJoinSelectOne(final int id)
{
return (Users)DaoTemplate.execute(new ICallBack() {
public Object exeSession(SqlSession s) {
Users user = s.selectOne("users.select_join_one", id);
return user;
}
});
}
/**
* 测试关联查询
*/
@Test
public List<Users> tsJoinSelectAll()
{
return (List<Users>) DaoTemplate.execute(new ICallBack() {
public Object exeSession(SqlSession s) {
List<Users> usersList = s.selectList("users.select_join_all");
return usersList;
}
});
}
}
6.App测试
-----------------------------------
package test.ssm.domain;
import dao.UserDao;
import java.util.List;
public class App {
public static void main(String [] args)
{
UserDao userDao = new UserDao();
Users u = new Users();
u.setName("gegege");
u.setAge(123);
//userDao.insert(u);
//List<Users> list = userDao.tsJoinSelectAll();
/*for(Users user : list)
{
List<Orders> list1 = user.getList();
for(Orders o : list1)
{
System.out.println(user.getId() + ":" + user.getName() + ":" + user.getAge() + ":" + o.getId() + ":" + o.getOrderno());
}
}*/
Users user = userDao.tsJoinSelectOne(2);
List<Orders> list1 = user.getList();
for(Orders o : list1)
{
System.out.println(user.getId() + ":" + user.getName() + ":" + user.getAge() + ":" + o.getId() + ":" + o.getOrderno());
}
}
}