++ +转载请注明出处：http://blog.csdn.net/qq_26525215
+
+本文源自【大学之旅_谙忆的博客】
准备两个表，学生表，和学院表，它们的关系是一对多，一个学生对应一个学院，一个学院可以对应多个学生。
+在此：
+1、演示利用一对多关系进行级联查询，也就是，只查询某个学院，同时将学院中的所有学生查询出来。
+2、演示利用一对多关系进行级联存储，也就是说，只存储学院，但是同时将学生信息存储进学生表。
准备的数据库数据:
+ +create database hib charset=utf8;
+use hib;
+create table students(
+ sId varchar(8) primary key,
+ sName varchar(40),
+ sAge int,
+ deptId varchar(8)
+);
+
+create table depts(
+ dId varchar(8) primary key,
+ dName varchar(40)
+);
+
+alter table students add(constraint fk_stu_dept foreign key(deptId) references dept(dId));
+
+insert into depts(dId,dName) values('D001','信息科学与工程学院');
+insert into depts(dId,dName) values('D002','土木工程学院');
+insert into depts(dId,dName) values('D003','数学与计算机学院');
+insert into depts(dId,dName) values('D004','通信学院');
+
+insert into students(sId,sName,sAge,deptId) values('S001','Jack',23,'D001');
+insert into students(sId,sName,sAge,deptId) values('S002','Tom',25,'D001');
+insert into students(sId,sName,sAge,deptId) values('S003','张三',43,'D001');
+insert into students(sId,sName,sAge,deptId) values('S004','李四',55,'D001');
+insert into students(sId,sName,sAge,deptId) values('S005','Jack',23,'D002');
+insert into students(sId,sName,sAge,deptId) values('S006','Tom',25,'D003');
+insert into students(sId,sName,sAge,deptId) values('S007','张三',43,'D002');
+insert into students(sId,sName,sAge,deptId) values('S008','李四',55,'D002');students表数据如下:
+ +
depts表数据如下:
+ +
因为代码比较多，只演示部分代码，完整代码在后面会给出链接。
+需要的JAR包，也全部在项目中，下载完整项目即可。
index.jsp:
+ + + +<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+<title>Hibernate中表之间的一对多关系</title>
+<style type="text/css">
+table {
+ border: 1px solid gray;
+ border-collapse: collapse;
+ width: 60%;
+}
+
+td {
+ border: 1px solid gray;
+ padding: 5px;
+}
+</style>
+</head>
+
+<body>
+ <h3>通过学院id查询学院表，把该学院的学生信息也同时输出来</h3>
+ <form action="<c:url value='/DemoServlet?cmd=queryDeptById'/>"
+ method="post">
+ <table>
+ <tr>
+ <td>学院编号<font color="red">*</font>
+ </td>
+ <td><input type="text" name="deptId"></td>
+ </tr>
+ <tr>
+ <td colspan="2" align="center"><input type="submit" value="查询">
+ </td>
+ </tr>
+ </table>
+ </form>
+
+ <c:if test="${!empty sessionScope.map }">
+ <h3>查询结果</h3>
+ 学院名称:${map.deptName}
+ <table>
+ <tr>
+ <td>学号</td>
+ <td>姓名</td>
+ <td>年龄</td>
+ <td>学院编号</td>
+ </tr>
+ <c:forEach items="${map.qlist}" var="stud">
+ <tr>
+ <td>${stud.sId}</td>
+ <td>${stud.sName}</td>
+ <td>${stud.sAge}</td>
+ <td>${stud.dept.dId}</td>
+ </tr>
+ </c:forEach>
+ </table>
+ <c:remove var="map"/>
+ </c:if>
+
+ <h3>添加学生/学院</h3>
+ <form action="<c:url value='/DemoServlet?cmd=addDept'/>" method="post">
+ <table>
+ <tr>
+ <td>学院编号<font color="red">*</font>
+ </td>
+ <td><input type="text" name="deptId"></td>
+ </tr>
+ <tr>
+ <td>学院名称
+ </td>
+ <td><input type="text" name="deptName"></td>
+ </tr>
+ <tr>
+ <td align="center">学生学号<font color="red">*</font>
+ </td>
+ <td align="center"><input type="text" name="studId"></td>
+ </tr>
+ <tr>
+ <td align="center">学生姓名<font color="red">*</font>
+ </td>
+ <td align="center"><input type="text" name="studName"></td>
+ </tr>
+ <tr>
+ <td align="center">学生年龄<font color="red">*</font>
+ </td>
+ <td align="center"><input type="text" name="studAge"></td>
+ </tr>
+ <tr>
+ <td colspan="2" align="center"><input type="submit" value="存储"></td>
+ </tr>
+ </table>
+ </form>
+
+</body>
+</html>
+DemoJdbcDao.java
+ +数据层。
+ + + +package cn.hncu.demo.dao;
+
+import org.hibernate.Query;
+import org.hibernate.Session;
+import org.hibernate.Transaction;
+
+import cn.hncu.domain.Dept;
+import cn.hncu.domain.Student;
+import cn.hncu.hib.HibernateSessionFactory;
+
+public class DemoJdbcDao {
+ public Dept queryDeptById(Dept dept) {
+ Session s = HibernateSessionFactory.getSession();
+ String hql = "from Dept d where d.dId=?";
+ //String hql = "from Dept";
+ Query query = s.createQuery(hql);
+ query.setParameter(0, dept.getdId());
+ //根据部门ID去查的，只会有一个查询结果
+ Dept resDept = (Dept) query.list().get(0);
+ return resDept;
+ }
+
+ public void addDept(Dept dept) {
+ Session s = HibernateSessionFactory.getSession();
+ if(dept.getdName()==null){
+ Query query = s.createQuery("from Dept d where d.dId=?");
+ query.setParameter(0, dept.getdId());
+ //对于学院存在的，如果没有填写学院名称，为其补上
+ dept.setdName( ((Dept) query.list().get(0)).getdName() );
+ }
+ s.clear();//把之前的session信息清空，因为不允许一个session对象进行几个操作
+ Transaction tx = s.beginTransaction();
+ s.saveOrUpdate(dept);
+ tx.commit();
+ }
+
+}
+DemoServlet
+ +servlet层
+ + + +package cn.hncu.demo;
+
+
+import java.io.PrintWriter;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import cn.hncu.demo.service.DemoServiceImpl;
+import cn.hncu.domain.Dept;
+import cn.hncu.domain.Student;
+import cn.hncu.utils.BaseServlet;
+
+public class DemoServlet extends BaseServlet {
+ DemoServiceImpl service = new DemoServiceImpl();
+ @Override
+ public void execute(HttpServletRequest req, HttpServletResponse resp)
+ throws Exception {
+
+ }
+
+ public void queryDeptById(HttpServletRequest req, HttpServletResponse resp)
+ throws Exception {
+ String deptId = req.getParameter("deptId");
+ if(deptId==null||deptId.trim().length()==0){
+ resp.sendRedirect(getServletContext().getContextPath());
+ return;
+ }
+ Dept dept = new Dept();
+ dept.setdId(deptId);
+ dept = service.queryDeptById(dept);
+ Map<String, Object> map = new HashMap<String, Object>();
+
+ map.put("deptName", dept.getdName());
+ map.put("qlist", dept.getStudents());
+
+ req.getSession().setAttribute("map", map);
+ resp.sendRedirect(getServletContext().getContextPath());
+ }
+
+ public void addDept(HttpServletRequest req, HttpServletResponse resp)
+ throws Exception {
+ String deptId = req.getParameter("deptId");
+ String deptName = req.getParameter("deptName");
+ if(deptName==null||deptName.trim().equals("")){
+ deptName=null;
+ }
+ String studId = req.getParameter("studId");
+ String studName = req.getParameter("studName");
+ String studAge = req.getParameter("studAge");
+ int age = Integer.parseInt(studAge);
+
+ Dept dept = new Dept();
+ dept.setdId(deptId);
+ dept.setdName(deptName);
+
+ Student s1 = new Student();
+ s1.setsId(studId);
+ s1.setsName(studName);
+ s1.setsAge(age);
+ s1.setDept(dept);//多方进行设置外键
+
+ //把多方添加到一方的集合中
+ dept.getStudents().add(s1);
+
+ service.addDept(dept);
+
+ resp.sendRedirect(getServletContext().getContextPath());
+ }
+
+}
+演示结果：
+ +开始显示页面:
+ +
查询D002学院:
+ +
为D002学院添加学生:
+ +
结果:
+
添加D005学院-科技学院
+ +
结果
+ +
完整的项目链接:
+ +小小的总结:
+ +此项目，我写的时候比较急，因为马上要学Spring框架了，有些方面没考虑到，有兴趣的可以自己取完善一下。例如，在增加学院和学生的时候，增加一个按钮，添加学生。再比如，把service,DAO层完善一下，写好接口，最好再写个过滤器，全站压缩，编码啥的。哈哈，自己可以加功能的。
+ ++转载请注明出处：http://blog.csdn.net/qq_26525215
+
+本文源自【大学之旅_谙忆的博客】
通过学院id查询学院表，把该学院的学生信息也同时输出来
+ + +查询结果
+ 学院名称:${map.deptName} +| 学号 | +姓名 | +年龄 | +学院编号 | +
| ${stud.sId} | +${stud.sName} | +${stud.sAge} | +${stud.dept.dId} | +
添加学生/学院
+ + + + diff --git a/Hibernate/myHibWeb2/myHibWeb2.zip b/Hibernate/myHibWeb2/myHibWeb2.zip new file mode 100644 index 0000000..2cc52b7 Binary files /dev/null and b/Hibernate/myHibWeb2/myHibWeb2.zip differ diff --git a/Hibernate/myHibWeb2/src/cn/hncu/demo/DemoServlet.java b/Hibernate/myHibWeb2/src/cn/hncu/demo/DemoServlet.java new file mode 100644 index 0000000..0c4255c --- /dev/null +++ b/Hibernate/myHibWeb2/src/cn/hncu/demo/DemoServlet.java @@ -0,0 +1,74 @@ +package cn.hncu.demo; + + +import java.io.PrintWriter; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.servlet.http.HttpServletRequest; +import javax.servlet.http.HttpServletResponse; + +import cn.hncu.demo.service.DemoServiceImpl; +import cn.hncu.domain.Dept; +import cn.hncu.domain.Student; +import cn.hncu.utils.BaseServlet; + +public class DemoServlet extends BaseServlet { + DemoServiceImpl service = new DemoServiceImpl(); + @Override + public void execute(HttpServletRequest req, HttpServletResponse resp) + throws Exception { + + } + + public void queryDeptById(HttpServletRequest req, HttpServletResponse resp) + throws Exception { + String deptId = req.getParameter("deptId"); + if(deptId==null||deptId.trim().length()==0){ + resp.sendRedirect(getServletContext().getContextPath()); + return; + } + Dept dept = new Dept(); + dept.setdId(deptId); + dept = service.queryDeptById(dept); + Map++ +转载请注明出处：http://blog.csdn.net/qq_26525215
+
+本文源自【大学之旅_谙忆的博客】
准备两个表，学生表，和学院表，它们的关系是一对多，一个学生对应一个学院，一个学院可以对应多个学生。
+在此：
+1、演示利用一对多关系进行级联查询，也就是，只查询某个学院，同时将学院中的所有学生查询出来。
+2、演示利用一对多关系进行级联存储，也就是说，只存储学院，但是同时将学生信息存储进学生表。
准备的数据库数据:
+ +create database hib charset=utf8;
+use hib;
+create table students(
+ sId varchar(8) primary key,
+ sName varchar(40),
+ sAge int,
+ deptId varchar(8)
+);
+
+create table depts(
+ dId varchar(8) primary key,
+ dName varchar(40)
+);
+
+alter table students add(constraint fk_stu_dept foreign key(deptId) references dept(dId));
+
+insert into depts(dId,dName) values('D001','信息科学与工程学院');
+insert into depts(dId,dName) values('D002','土木工程学院');
+insert into depts(dId,dName) values('D003','数学与计算机学院');
+insert into depts(dId,dName) values('D004','通信学院');
+
+insert into students(sId,sName,sAge,deptId) values('S001','Jack',23,'D001');
+insert into students(sId,sName,sAge,deptId) values('S002','Tom',25,'D001');
+insert into students(sId,sName,sAge,deptId) values('S003','张三',43,'D001');
+insert into students(sId,sName,sAge,deptId) values('S004','李四',55,'D001');
+insert into students(sId,sName,sAge,deptId) values('S005','Jack',23,'D002');
+insert into students(sId,sName,sAge,deptId) values('S006','Tom',25,'D003');
+insert into students(sId,sName,sAge,deptId) values('S007','张三',43,'D002');
+insert into students(sId,sName,sAge,deptId) values('S008','李四',55,'D002');students表数据如下:
+ +depts表数据如下:
+ +因为代码比较多，只演示部分代码，完整代码在后面会给出链接。
+需要的JAR包，也全部在项目中，下载完整项目即可。
index.jsp:
+ + + +<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
+<%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
+
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+<head>
+<title>Hibernate中表之间的一对多关系</title>
+<style type="text/css">
+table {
+ border: 1px solid gray;
+ border-collapse: collapse;
+ width: 60%;
+}
+
+td {
+ border: 1px solid gray;
+ padding: 5px;
+}
+</style>
+</head>
+
+<body>
+ <h3>通过学院id查询学院表，把该学院的学生信息也同时输出来</h3>
+ <form action="<c:url value='/DemoServlet?cmd=queryDeptById'/>"
+ method="post">
+ <table>
+ <tr>
+ <td>学院编号<font color="red">*</font>
+ </td>
+ <td><input type="text" name="deptId"></td>
+ </tr>
+ <tr>
+ <td colspan="2" align="center"><input type="submit" value="查询">
+ </td>
+ </tr>
+ </table>
+ </form>
+
+ <c:if test="${!empty sessionScope.map }">
+ <h3>查询结果</h3>
+ 学院名称:${map.deptName}
+ <table>
+ <tr>
+ <td>学号</td>
+ <td>姓名</td>
+ <td>年龄</td>
+ <td>学院编号</td>
+ </tr>
+ <c:forEach items="${map.qlist}" var="stud">
+ <tr>
+ <td>${stud.sId}</td>
+ <td>${stud.sName}</td>
+ <td>${stud.sAge}</td>
+ <td>${stud.dept.dId}</td>
+ </tr>
+ </c:forEach>
+ </table>
+ <c:remove var="map"/>
+ </c:if>
+
+ <h3>添加学生/学院</h3>
+ <form action="<c:url value='/DemoServlet?cmd=addDept'/>" method="post">
+ <table>
+ <tr>
+ <td>学院编号<font color="red">*</font>
+ </td>
+ <td><input type="text" name="deptId"></td>
+ </tr>
+ <tr>
+ <td>学院名称
+ </td>
+ <td><input type="text" name="deptName"></td>
+ </tr>
+ <tr>
+ <td align="center">学生学号<font color="red">*</font>
+ </td>
+ <td align="center"><input type="text" name="studId"></td>
+ </tr>
+ <tr>
+ <td align="center">学生姓名<font color="red">*</font>
+ </td>
+ <td align="center"><input type="text" name="studName"></td>
+ </tr>
+ <tr>
+ <td align="center">学生年龄<font color="red">*</font>
+ </td>
+ <td align="center"><input type="text" name="studAge"></td>
+ </tr>
+ <tr>
+ <td colspan="2" align="center"><input type="submit" value="存储"></td>
+ </tr>
+ </table>
+ </form>
+
+</body>
+</html>
+DemoJdbcDao.java
+ +数据层。
+ + + +package cn.hncu.demo.dao;
+
+import org.hibernate.Query;
+import org.hibernate.Session;
+import org.hibernate.Transaction;
+
+import cn.hncu.domain.Dept;
+import cn.hncu.domain.Student;
+import cn.hncu.hib.HibernateSessionFactory;
+
+public class DemoJdbcDao {
+ public Dept queryDeptById(Dept dept) {
+ Session s = HibernateSessionFactory.getSession();
+ String hql = "from Dept d where d.dId=?";
+ //String hql = "from Dept";
+ Query query = s.createQuery(hql);
+ query.setParameter(0, dept.getdId());
+ //根据部门ID去查的，只会有一个查询结果
+ Dept resDept = (Dept) query.list().get(0);
+ return resDept;
+ }
+
+ public void addDept(Dept dept) {
+ Session s = HibernateSessionFactory.getSession();
+ if(dept.getdName()==null){
+ Query query = s.createQuery("from Dept d where d.dId=?");
+ query.setParameter(0, dept.getdId());
+ //对于学院存在的，如果没有填写学院名称，为其补上
+ dept.setdName( ((Dept) query.list().get(0)).getdName() );
+ }
+ s.clear();//把之前的session信息清空，因为不允许一个session对象进行几个操作
+ Transaction tx = s.beginTransaction();
+ s.saveOrUpdate(dept);
+ tx.commit();
+ }
+
+}
+DemoServlet
+ +servlet层
+ + + +package cn.hncu.demo;
+
+
+import java.io.PrintWriter;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import cn.hncu.demo.service.DemoServiceImpl;
+import cn.hncu.domain.Dept;
+import cn.hncu.domain.Student;
+import cn.hncu.utils.BaseServlet;
+
+public class DemoServlet extends BaseServlet {
+ DemoServiceImpl service = new DemoServiceImpl();
+ @Override
+ public void execute(HttpServletRequest req, HttpServletResponse resp)
+ throws Exception {
+
+ }
+
+ public void queryDeptById(HttpServletRequest req, HttpServletResponse resp)
+ throws Exception {
+ String deptId = req.getParameter("deptId");
+ if(deptId==null||deptId.trim().length()==0){
+ resp.sendRedirect(getServletContext().getContextPath());
+ return;
+ }
+ Dept dept = new Dept();
+ dept.setdId(deptId);
+ dept = service.queryDeptById(dept);
+ Map<String, Object> map = new HashMap<String, Object>();
+
+ map.put("deptName", dept.getdName());
+ map.put("qlist", dept.getStudents());
+
+ req.getSession().setAttribute("map", map);
+ resp.sendRedirect(getServletContext().getContextPath());
+ }
+
+ public void addDept(HttpServletRequest req, HttpServletResponse resp)
+ throws Exception {
+ String deptId = req.getParameter("deptId");
+ String deptName = req.getParameter("deptName");
+ if(deptName==null||deptName.trim().equals("")){
+ deptName=null;
+ }
+ String studId = req.getParameter("studId");
+ String studName = req.getParameter("studName");
+ String studAge = req.getParameter("studAge");
+ int age = Integer.parseInt(studAge);
+
+ Dept dept = new Dept();
+ dept.setdId(deptId);
+ dept.setdName(deptName);
+
+ Student s1 = new Student();
+ s1.setsId(studId);
+ s1.setsName(studName);
+ s1.setsAge(age);
+ s1.setDept(dept);//多方进行设置外键
+
+ //把多方添加到一方的集合中
+ dept.getStudents().add(s1);
+
+ service.addDept(dept);
+
+ resp.sendRedirect(getServletContext().getContextPath());
+ }
+
+}
+演示结果：
+ +开始显示页面:
+ +查询D002学院:
+ +为D002学院添加学生:
+ +结果:
+
添加D005学院-科技学院
+ +结果
+ +完整的项目链接:
+ +小小的总结:
+ +此项目，我写的时候比较急，因为马上要学Spring框架了，有些方面没考虑到，有兴趣的可以自己取完善一下。例如，在增加学院和学生的时候，增加一个按钮，添加学生。再比如，把service,DAO层完善一下，写好接口，最好再写个过滤器，全站压缩，编码啥的。哈哈，自己可以加功能的。
+ ++转载请注明出处：http://blog.csdn.net/qq_26525215
+
+本文源自【大学之旅_谙忆的博客】
++ + + +转载请注明出处：http://blog.csdn.net/qq_26525215
+
+本文源自【大学之旅_谙忆的博客】
Hibernate介绍:
+ +Hibernate是一个开放源码的、非常优秀、成熟的O/R Mapping框架。它提供了强大、高性能的Java对象和关系数据的持久化和查询功能。
+ +O/R Mapping
+对象关系映射（Object Relational Mapping，简称ORM）技术，是通过使用描述对象和数据库之间映射的元数据，将Java程序中的对象自动持久化到关系数据库中。
+对象和关系数据是业务实体的两种表现形式，业务实体在内存中表现为对象，在数据库中表现为关系数据。内存中的对象之间存在关联和继承关系，而在数据库中，关系数据无法直接表达多对多关联和继承关系。因此，对象-关系映射(ORM)系统一般以中间件的形式存在，主要实现程序对象到关系数据库数据的映射。
Hibernate 只是一个将持久化类与数据库表相映射的工具，每个持久化类实例均对应于数据库表中的一条数据行。可以使用面向对象的方法操作此持久化类实例，完成对数据库表的插入、删除、修改等操作。
+ +利用Hibernate操作数据库，我们通过应用程序经过Hibernate持久层来访问数据库，其实Hibernate完成了以前JDBC的功能，不过Hibernate使用面向对象的方法操作数据库。
+ + + +Hibernate体系结构图:
+ +
Hibernate构架入门步骤
+ +第1步： 先建一个Java工程导入使用Hibernate最小必要包。
+一般在解压后的lib目录下的
+
+required目录下。
+可以到官方网站 http://hibernate.org/orm/downloads/ 下载Hibernate最新的zip压缩包。
+如果访问数据库，则还需要导入数据库的驱动包。
+mysql-connector-java-5.1.39 .zip下载地址:
++ +
第2步：在src创建配置文件hibernate.cfg.xml，放置在src目录下。
+ +第3步：编写一个会话工厂类。通过会话工厂类产生一个会话Session对象。Session对象是Hibernate的核心。任何对数据库操作都在会话中进行的。
+ +对于熟悉C3P0的朋友，可以按下面的理解:
+(配置文件hibernate.cfg.xml可以类比c3p0.properties的配置文件，HibernateSessionFactory可以类比C3p0Pool，SessionFactory可以类比C3p0中的DataSource，Session可以类比Connection去理解)
第4步：编写POJO类以及映射文件。
+POJO(POJO（Plain Ordinary Java Object）简单的Java对象，实际就是普通JavaBeans)
第5步：编写测试文件
+ +hibernate.cfg.xml配置文件详解
+ +hibernate.cfg.xml其实这个名字自己可以随便取的，但是大家都这么取名，于是形成了一个习惯了！！！
+ +<?xml version='1.0' encoding='UTF-8'?>
+<!--标准的XML文件的起始行，version='1.0'表明XML的版本，encoding='UTF-8'表明XML文件的编码方式 -->
+
+<!--表明解析本XML文件的DTD文档位置，DTD是Document Type Definition 的缩写,即文档类型的定义,
+XML解析器使用DTD文档来检查XML文件的合法性。
+hibernate.sourceforge.net/hibernate-configuration-3.0dtd可以在Hibernate3.1.3软件包中的
+src\org\hibernate目录中找到此文件-->
+<!DOCTYPE hibernate-configuration PUBLIC
+ "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
+ "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
+
+<!--声明Hibernate配置文件的开始 -->
+<hibernate-configuration>
+
+ <!--表明以下的配置是针对session-factory配置的，SessionFactory是Hibernate中的一个类，
+ 这个类主要负责保存HIbernate的配置信息，以及对Session的操作-->
+ <session-factory>
+ <!--配置数据库的驱动程序，Hibernate在连接数据库时，需要用到数据库的驱动程序-必须 -->
+ <property name="connection.driver_class">
+ com.mysql.jdbc.Driver
+ </property>
+ <!--设置数据库的连接url:jdbc:mysql://127.0.0.1:3306/hib,其中127.0.0.1表示mysql服务器名称,
+ 3306是连接端口，此处为本机,hib是数据库名-必须 -->
+ <property name="connection.url">
+ jdbc:mysql://127.0.0.1:3306/hib
+ </property>
+ <!-- 设置数据库的用户名 -必须 -->
+ <property name="connection.username">root</property>
+ <!-- 设置数据库的密码 -必须 -->
+ <property name="connection.password">1234</property>
+ <!--数据库连接池的大小 -->
+ <!-- <property name="connection.pool.size">20 </property> 与下句是一样的 -->
+ <property name="hibernate.connection.pool.size">20 </property>
+
+ <!--是否在后台显示Hibernate用到的SQL语句，开发时设置为true，便于查错，
+ 程序运行时可以在Eclipse的控制台显示Hibernate的执行Sql语句。
+ 项目部署后可以设置为false，提高运行效率-->
+ <property name="hibernate.show_sql">true </property>
+
+ <!--jdbc.fetch_size是指Hibernate每次从数据库中取出并放到JDBC的Statement中的记录条数。
+ Fetch Size设的越大，读数据库的次数越少，速度越快，Fetch Size越小，读数据库的次数越多，速度越慢-->
+ <property name="jdbc.fetch_size">50 </property>
+
+ <!--jdbc.batch_size是指Hibernate批量插入,删除和更新时每次操作的记录数。
+ Batch Size越大，批量操作的向数据库发送Sql的次数越少，速度就越快，同样耗用内存就越大-->
+ <property name="jdbc.batch_size">23 </property>
+
+ <!--jdbc.use_scrollable_resultset是否允许Hibernate用JDBC的可滚动的结果集。
+ 对分页的结果集。对分页时的设置非常有帮助-->
+ <property name="jdbc.use_scrollable_resultset">false </property>
+
+ <!--connection.useUnicode连接数据库时是否使用Unicode编码-->
+ <property name="connection.useUnicode">true</property>
+ <!--connection.characterEncoding连接数据库时数据的传输字符集编码方式-->
+ <property name="connection.characterEncoding">utf-8</property>
+
+
+<!--hibernate.dialect 只是Hibernate使用的数据库方言,就是要用Hibernate连接那种类型的数据库服务器。-->
+ <!--这句不用管，照写就是 -必须 -->
+ <property name="dialect">
+ org.hibernate.dialect.MySQLDialect
+ </property>
+
+ <!-- 指定映射文件为“cn/hncu/domain/Student.hbm.xml”，可以有多个 -用到了就必须 -->
+ <mapping resource="cn/hncu/domain/Student.hbm.xml" />
+ </session-factory>
+
+</hibernate-configuration>简单配置版:
+ + + +<?xml version='1.0' encoding='UTF-8'?>
+<!DOCTYPE hibernate-configuration PUBLIC
+ "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
+ "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
+<hibernate-configuration>
+<!-- 这是最简单的配置版！！！ -->
+<session-factory>
+ <property name="connection.driver_class">
+ com.mysql.jdbc.Driver
+ </property>
+ <property name="connection.url">
+ jdbc:mysql://127.0.0.1:3306/hib
+ </property>
+ <property name="connection.username">root</property>
+ <property name="connection.password">1234</property>
+
+ <property name="dialect">
+ org.hibernate.dialect.MySQLDialect
+ </property>
+
+ <mapping resource="cn/hncu/domain/Student.hbm.xml"/>
+</session-factory>
+
+</hibernate-configuration>Hibernate核心接口
+ +(1) Configuration接口
+ +Configuration 接口负责管理Hibernate 的配置信息。为了能够连上数据库必须配置一些属性，这些属性包括：
+数据库URL
+数据库用户
+数据库用户密码
+数据库JDBC驱动类
+数据库dialect，用于对特定数据库提供支持，其中包含了针对特定数据库特性的实现。
/*创建一个配置对象，读取配置文件*/
+ Configuration config = new Configuration();
+ config.configure("/hibernate.cfg.xml");
+(2) SessionFactory接口
+ +应用程序从SessionFactory（会话工厂）里获得Session(会话)实例。
+这里用到了一个设计模式即工厂模式，用户程序从工厂类SessionFactory中取得Session的实例。
+SessionFactory不是轻量级的。它占的资源比较多，所以它应该能在整个应用中共享。
+一个项目通常只需要一个SessionFactory就够了，但是当项目要操作多个数据库时，必须为每个数据库指定一个SessionFactory。
+会话工厂缓存了生成的SQL语句和Hibernate在运行时使用的映射元数据。它也保存了在一个工作单元中读入的数据并且可能在以后的工作单元中被重用（只有类和集合映射指定了使用这种二级缓存时才会如此）Session类。
/*通过配置对象产生一个会话工厂*/
+ SessionFactory factory=config.buildSessionFactory();
+(3) Session接口
+ +该接口是Hibernate使用最多的接口。Session不是线程安全的，它代表与数据库之间的一次操作。
+Session是持久层操作的基础，相当于JDBC中的Connection。然而在Hibernate中，实例化的Session是一个轻量级的类，创建和销毁它都不会占用很多资源。
+Session通过SessionFactory打开，在所有的工作完成后，需要关闭。但如果在程序中，不断地创建以及销毁Session对象，则会给系统带来不良影响。所以有时需要考虑session的管理合理的创建合理的销毁。
/*通过工厂产生一个会话*/
+ Session session=factory.openSession();
+(4) Query类
+ +Query类可以很方便地对数据库及持久对象进行查询，它可以有两种表达方式：查询语句使用HQL(面向”值对象”，HQL语言) （HQL是Hibernate Query Lanaguage简称是Hibernate配备了一种非常强大的查询语言，类似于SQL）或者本地数据库的SQL语句(面向”数据表”，SQL语言)编写。
+ + + +/*通过会话产生一个查询对象*/
+ Query query = session.createQuery("from Student");//Student是POJO类，需要在配置文件中设置好映射
+ /*通过查询对象查询数据库，返回集合*/
+ List list = query.list();
+ for (int i = 0; i < list.size(); i++) {
+ Student student= (Student) list.get(i);
+ System.out.println(Student.getDname());
+ }(5) Transaction接口
+ +如果你向数据库中增加数据或修改数据时，需要使用事务处理，这时你需要Transaction接口。
+ Transaction接口是对实际事务实现的一个抽象，该接口可以实现JDBC的事务、JTA中的UserTransaction、甚至可以是CORBA事务等跨容器的事务。
+ 之所以这样设计是能让开发者能够使用一个统一事务的操作界面，使得自己的项目可以在不同的环境和容器之间方便地移值。
一个完整示例,显示了Hibernate编程基本思路
+ + + +首先，准备好实例数据库：
+ +create database hib charset=utf8;
+use hib;
+create table students(
+ sId varchar(8) primary key,
+ sName varchar(40),
+ sAge int
+);
+insert into students(sId,sName,sAge) values('S001','Jack',23);
+insert into students(sId,sName,sAge) values('S002','Tom',25);
+insert into students(sId,sName,sAge) values('S003','张三',43);
+insert into students(sId,sName,sAge) values('S004','李四',55);准备好必要的jar包。
+ +接下来配置好hibernate.cfg.xml文件:
+ +前面有的，就不重复了，配个图好了。
+
POJO类:
+ + + +package cn.hncu.domain;
+
+public class Student {
+ private String sId;
+ private String sName;
+ private Integer sAge;
+
+ public Student() {
+ super();
+ }
+ public String getsId() {
+ return sId;
+ }
+ public void setsId(String sId) {
+ this.sId = sId;
+ }
+ public String getsName() {
+ return sName;
+ }
+ public void setsName(String sName) {
+ this.sName = sName;
+ }
+ public Integer getsAge() {
+ return sAge;
+ }
+ public void setsAge(Integer sAge) {
+ this.sAge = sAge;
+ }
+ @Override
+ public String toString() {
+ return "Student [sId=" + sId + ", sName=" + sName + ", sAge=" + sAge
+ + "]";
+ }
+}
+cn/hncu/domain/Student.hbm.xml映射文件
+ + + +<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
+"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
+
+<hibernate-mapping package="cn.hncu.domain">
+
+ <!--name指的是POJO类的类名，table是数据库的表名，catalog是数据库的名称 -->
+ <class name="Student" table="students" catalog="hib">
+ <!--id表示此字段为数据库的主键，这里也可以用property来写，name为Student类的成员变量名，type为类型的包全名 -->
+ <id name="sId" type="java.lang.String">
+ <!--column表示映射的数据库的字段，name表示数据库中字段名，length表示varchar/char型的长度 -->
+ <column name="sId" length="8"></column>
+ </id>
+ <property name="sName" type="java.lang.String">
+ <column name="sName" length="40" />
+ </property>
+ <property name="sAge" type="java.lang.Integer">
+ <column name="sAge" />
+ </property>
+ </class>
+
+</hibernate-mapping>HibernateSessionFactory
+ + + +package cn.hncu.hib;
+
+import org.hibernate.HibernateException;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.cfg.Configuration;
+
+public class HibernateSessionFactory {
+ private static String configFile = "/hibernate.cfg.xml";
+ private static Configuration config = new Configuration();
+ private static SessionFactory sessionFactory =null;
+
+ private static final ThreadLocal<Session> t = new ThreadLocal<Session>();
+
+ static{
+ try {
+ /*创建一个配置对象，读取配置文件*/
+ config.configure(configFile);
+ /*通过配置对象产生一个会话工厂类*/
+ sessionFactory = config.buildSessionFactory();
+ } catch (HibernateException e) {
+ e.printStackTrace();
+ }
+ }
+
+ public static Session getSession() throws HibernateException{
+ Session session = t.get();
+ if(session == null || !session.isOpen()){
+ if(sessionFactory==null){
+ rebuildSessionFactory();
+ }
+ /*通过会话工厂类产生一个会话实例*/
+ session = (sessionFactory!=null) ? sessionFactory.openSession() : null;
+ t.set(session);
+ }
+ return session;
+ }
+
+ private static void rebuildSessionFactory() {
+ try {
+ config.configure(configFile);
+ sessionFactory = config.buildSessionFactory();
+ } catch (HibernateException e) {
+ e.printStackTrace();
+ }
+ }
+
+ //关闭与数据库的会话
+ public static void closeSession() throws HibernateException{
+ Session session = t.get();
+ t.set(null);
+ if(session!=null){
+ session.close();
+ }
+ }
+}TestHib
+ + + +package cn.hncu;
+
+import java.util.List;
+
+import org.hibernate.Query;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.cfg.Configuration;
+
+import cn.hncu.domain.Student;
+import cn.hncu.hib.HibernateSessionFactory;
+
+public class TestHib {
+
+ public static void main(String[] args) {
+ /*创建一个配置对象，读取配置文件*/
+ String configfile="/hibernate.cfg.xml";
+ Configuration config=new Configuration();
+ config.configure(configfile);
+ /*通过配置对象产生一个会话工厂类*/
+ SessionFactory sessionfactory=config.buildSessionFactory();
+ /*通过会话工厂类产生一个会话实例*/
+ Session session=sessionfactory.openSession();
+ /*通过会话产生一个查询对象Query*/
+ Query query=session.createQuery("from Student");
+ /*进行查询返回一个集合List*/
+ List<Student> studs=query.list();
+ for(Student s:studs){
+ System.out.println(s);
+ }
+
+ session = HibernateSessionFactory.getSession();
+ query = session.createQuery("from Student");
+ List<Student> students = query.list();
+ for(Student s: students){
+ System.out.println(s);
+ }
+ }
+}
+测试结果:
+ +
+转载请注明出处：http://blog.csdn.net/qq_26525215
+
+本文源自【大学之旅_谙忆的博客】
+ + diff --git a/Hibernate/myHibWebDemo/myHibWebDemo.zip b/Hibernate/myHibWebDemo/myHibWebDemo.zip new file mode 100644 index 0000000..b2648f2 Binary files /dev/null and b/Hibernate/myHibWebDemo/myHibWebDemo.zip differ diff --git a/Hibernate/myHibWebDemo/src/cn/hncu/TestHib.java b/Hibernate/myHibWebDemo/src/cn/hncu/TestHib.java new file mode 100644 index 0000000..04327db --- /dev/null +++ b/Hibernate/myHibWebDemo/src/cn/hncu/TestHib.java @@ -0,0 +1,39 @@ +package cn.hncu; + +import java.util.List; + +import org.hibernate.Query; +import org.hibernate.Session; +import org.hibernate.SessionFactory; +import org.hibernate.cfg.Configuration; + +import cn.hncu.domain.Student; +import cn.hncu.hib.HibernateSessionFactory; + +public class TestHib { + + public static void main(String[] args) { + /*创建一个配置对象，读取配置文件*/ + String configfile="/hibernate.cfg.xml"; + Configuration config=new Configuration(); + config.configure(configfile); + /*通过配置对象产生一个会话工厂类*/ + SessionFactory sessionfactory=config.buildSessionFactory(); + /*通过会话工厂类产生一个会话实例*/ + Session session=sessionfactory.openSession(); + /*通过会话产生一个查询对象Query*/ + Query query=session.createQuery("from Student"); + /*进行查询返回一个集合List*/ + List
++ + + +转载请注明出处：http://blog.csdn.net/qq_26525215
+
+本文源自【大学之旅_谙忆的博客】
Hibernate介绍:
+ +Hibernate是一个开放源码的、非常优秀、成熟的O/R Mapping框架。它提供了强大、高性能的Java对象和关系数据的持久化和查询功能。
+ +O/R Mapping
+对象关系映射（Object Relational Mapping，简称ORM）技术，是通过使用描述对象和数据库之间映射的元数据，将Java程序中的对象自动持久化到关系数据库中。
+对象和关系数据是业务实体的两种表现形式，业务实体在内存中表现为对象，在数据库中表现为关系数据。内存中的对象之间存在关联和继承关系，而在数据库中，关系数据无法直接表达多对多关联和继承关系。因此，对象-关系映射(ORM)系统一般以中间件的形式存在，主要实现程序对象到关系数据库数据的映射。
Hibernate 只是一个将持久化类与数据库表相映射的工具，每个持久化类实例均对应于数据库表中的一条数据行。可以使用面向对象的方法操作此持久化类实例，完成对数据库表的插入、删除、修改等操作。
+ +利用Hibernate操作数据库，我们通过应用程序经过Hibernate持久层来访问数据库，其实Hibernate完成了以前JDBC的功能，不过Hibernate使用面向对象的方法操作数据库。
+ + + +Hibernate体系结构图:
+ +Hibernate构架入门步骤
+ +第1步： 先建一个Java工程导入使用Hibernate最小必要包。
+一般在解压后的lib目录下的
+
+required目录下。
+可以到官方网站 http://hibernate.org/orm/downloads/ 下载Hibernate最新的zip压缩包。
+如果访问数据库，则还需要导入数据库的驱动包。
+mysql-connector-java-5.1.39 .zip下载地址:
++ +
第2步：在src创建配置文件hibernate.cfg.xml，放置在src目录下。
+ +第3步：编写一个会话工厂类。通过会话工厂类产生一个会话Session对象。Session对象是Hibernate的核心。任何对数据库操作都在会话中进行的。
+ +对于熟悉C3P0的朋友，可以按下面的理解:
+(配置文件hibernate.cfg.xml可以类比c3p0.properties的配置文件，HibernateSessionFactory可以类比C3p0Pool，SessionFactory可以类比C3p0中的DataSource，Session可以类比Connection去理解)
第4步：编写POJO类以及映射文件。
+POJO(POJO（Plain Ordinary Java Object）简单的Java对象，实际就是普通JavaBeans)
第5步：编写测试文件
+ +hibernate.cfg.xml配置文件详解
+ +hibernate.cfg.xml其实这个名字自己可以随便取的，但是大家都这么取名，于是形成了一个习惯了！！！
+ +<?xml version='1.0' encoding='UTF-8'?>
+<!--标准的XML文件的起始行，version='1.0'表明XML的版本，encoding='UTF-8'表明XML文件的编码方式 -->
+
+<!--表明解析本XML文件的DTD文档位置，DTD是Document Type Definition 的缩写,即文档类型的定义,
+XML解析器使用DTD文档来检查XML文件的合法性。
+hibernate.sourceforge.net/hibernate-configuration-3.0dtd可以在Hibernate3.1.3软件包中的
+src\org\hibernate目录中找到此文件-->
+<!DOCTYPE hibernate-configuration PUBLIC
+ "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
+ "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
+
+<!--声明Hibernate配置文件的开始 -->
+<hibernate-configuration>
+
+ <!--表明以下的配置是针对session-factory配置的，SessionFactory是Hibernate中的一个类，
+ 这个类主要负责保存HIbernate的配置信息，以及对Session的操作-->
+ <session-factory>
+ <!--配置数据库的驱动程序，Hibernate在连接数据库时，需要用到数据库的驱动程序-必须 -->
+ <property name="connection.driver_class">
+ com.mysql.jdbc.Driver
+ </property>
+ <!--设置数据库的连接url:jdbc:mysql://127.0.0.1:3306/hib,其中127.0.0.1表示mysql服务器名称,
+ 3306是连接端口，此处为本机,hib是数据库名-必须 -->
+ <property name="connection.url">
+ jdbc:mysql://127.0.0.1:3306/hib
+ </property>
+ <!-- 设置数据库的用户名 -必须 -->
+ <property name="connection.username">root</property>
+ <!-- 设置数据库的密码 -必须 -->
+ <property name="connection.password">1234</property>
+ <!--数据库连接池的大小 -->
+ <!-- <property name="connection.pool.size">20 </property> 与下句是一样的 -->
+ <property name="hibernate.connection.pool.size">20 </property>
+
+ <!--是否在后台显示Hibernate用到的SQL语句，开发时设置为true，便于查错，
+ 程序运行时可以在Eclipse的控制台显示Hibernate的执行Sql语句。
+ 项目部署后可以设置为false，提高运行效率-->
+ <property name="hibernate.show_sql">true </property>
+
+ <!--jdbc.fetch_size是指Hibernate每次从数据库中取出并放到JDBC的Statement中的记录条数。
+ Fetch Size设的越大，读数据库的次数越少，速度越快，Fetch Size越小，读数据库的次数越多，速度越慢-->
+ <property name="jdbc.fetch_size">50 </property>
+
+ <!--jdbc.batch_size是指Hibernate批量插入,删除和更新时每次操作的记录数。
+ Batch Size越大，批量操作的向数据库发送Sql的次数越少，速度就越快，同样耗用内存就越大-->
+ <property name="jdbc.batch_size">23 </property>
+
+ <!--jdbc.use_scrollable_resultset是否允许Hibernate用JDBC的可滚动的结果集。
+ 对分页的结果集。对分页时的设置非常有帮助-->
+ <property name="jdbc.use_scrollable_resultset">false </property>
+
+ <!--connection.useUnicode连接数据库时是否使用Unicode编码-->
+ <property name="connection.useUnicode">true</property>
+ <!--connection.characterEncoding连接数据库时数据的传输字符集编码方式-->
+ <property name="connection.characterEncoding">utf-8</property>
+
+
+<!--hibernate.dialect 只是Hibernate使用的数据库方言,就是要用Hibernate连接那种类型的数据库服务器。-->
+ <!--这句不用管，照写就是 -必须 -->
+ <property name="dialect">
+ org.hibernate.dialect.MySQLDialect
+ </property>
+
+ <!-- 指定映射文件为“cn/hncu/domain/Student.hbm.xml”，可以有多个 -用到了就必须 -->
+ <mapping resource="cn/hncu/domain/Student.hbm.xml" />
+ </session-factory>
+
+</hibernate-configuration>简单配置版:
+ + + +<?xml version='1.0' encoding='UTF-8'?>
+<!DOCTYPE hibernate-configuration PUBLIC
+ "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
+ "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
+<hibernate-configuration>
+<!-- 这是最简单的配置版！！！ -->
+<session-factory>
+ <property name="connection.driver_class">
+ com.mysql.jdbc.Driver
+ </property>
+ <property name="connection.url">
+ jdbc:mysql://127.0.0.1:3306/hib
+ </property>
+ <property name="connection.username">root</property>
+ <property name="connection.password">1234</property>
+
+ <property name="dialect">
+ org.hibernate.dialect.MySQLDialect
+ </property>
+
+ <mapping resource="cn/hncu/domain/Student.hbm.xml"/>
+</session-factory>
+
+</hibernate-configuration>Hibernate核心接口
+ +(1) Configuration接口
+ +Configuration 接口负责管理Hibernate 的配置信息。为了能够连上数据库必须配置一些属性，这些属性包括：
+数据库URL
+数据库用户
+数据库用户密码
+数据库JDBC驱动类
+数据库dialect，用于对特定数据库提供支持，其中包含了针对特定数据库特性的实现。
/*创建一个配置对象，读取配置文件*/
+ Configuration config = new Configuration();
+ config.configure("/hibernate.cfg.xml");
+(2) SessionFactory接口
+ +应用程序从SessionFactory（会话工厂）里获得Session(会话)实例。
+这里用到了一个设计模式即工厂模式，用户程序从工厂类SessionFactory中取得Session的实例。
+SessionFactory不是轻量级的。它占的资源比较多，所以它应该能在整个应用中共享。
+一个项目通常只需要一个SessionFactory就够了，但是当项目要操作多个数据库时，必须为每个数据库指定一个SessionFactory。
+会话工厂缓存了生成的SQL语句和Hibernate在运行时使用的映射元数据。它也保存了在一个工作单元中读入的数据并且可能在以后的工作单元中被重用（只有类和集合映射指定了使用这种二级缓存时才会如此）Session类。
/*通过配置对象产生一个会话工厂*/
+ SessionFactory factory=config.buildSessionFactory();
+(3) Session接口
+ +该接口是Hibernate使用最多的接口。Session不是线程安全的，它代表与数据库之间的一次操作。
+Session是持久层操作的基础，相当于JDBC中的Connection。然而在Hibernate中，实例化的Session是一个轻量级的类，创建和销毁它都不会占用很多资源。
+Session通过SessionFactory打开，在所有的工作完成后，需要关闭。但如果在程序中，不断地创建以及销毁Session对象，则会给系统带来不良影响。所以有时需要考虑session的管理合理的创建合理的销毁。
/*通过工厂产生一个会话*/
+ Session session=factory.openSession();
+(4) Query类
+ +Query类可以很方便地对数据库及持久对象进行查询，它可以有两种表达方式：查询语句使用HQL(面向”值对象”，HQL语言) （HQL是Hibernate Query Lanaguage简称是Hibernate配备了一种非常强大的查询语言，类似于SQL）或者本地数据库的SQL语句(面向”数据表”，SQL语言)编写。
+ + + +/*通过会话产生一个查询对象*/
+ Query query = session.createQuery("from Student");//Student是POJO类，需要在配置文件中设置好映射
+ /*通过查询对象查询数据库，返回集合*/
+ List list = query.list();
+ for (int i = 0; i < list.size(); i++) {
+ Student student= (Student) list.get(i);
+ System.out.println(Student.getDname());
+ }(5) Transaction接口
+ +如果你向数据库中增加数据或修改数据时，需要使用事务处理，这时你需要Transaction接口。
+ Transaction接口是对实际事务实现的一个抽象，该接口可以实现JDBC的事务、JTA中的UserTransaction、甚至可以是CORBA事务等跨容器的事务。
+ 之所以这样设计是能让开发者能够使用一个统一事务的操作界面，使得自己的项目可以在不同的环境和容器之间方便地移值。
一个完整示例,显示了Hibernate编程基本思路
+ + + +首先，准备好实例数据库：
+ +create database hib charset=utf8;
+use hib;
+create table students(
+ sId varchar(8) primary key,
+ sName varchar(40),
+ sAge int
+);
+insert into students(sId,sName,sAge) values('S001','Jack',23);
+insert into students(sId,sName,sAge) values('S002','Tom',25);
+insert into students(sId,sName,sAge) values('S003','张三',43);
+insert into students(sId,sName,sAge) values('S004','李四',55);准备好必要的jar包。
+ +接下来配置好hibernate.cfg.xml文件:
+ +前面有的，就不重复了，配个图好了。
+
POJO类:
+ + + +package cn.hncu.domain;
+
+public class Student {
+ private String sId;
+ private String sName;
+ private Integer sAge;
+
+ public Student() {
+ super();
+ }
+ public String getsId() {
+ return sId;
+ }
+ public void setsId(String sId) {
+ this.sId = sId;
+ }
+ public String getsName() {
+ return sName;
+ }
+ public void setsName(String sName) {
+ this.sName = sName;
+ }
+ public Integer getsAge() {
+ return sAge;
+ }
+ public void setsAge(Integer sAge) {
+ this.sAge = sAge;
+ }
+ @Override
+ public String toString() {
+ return "Student [sId=" + sId + ", sName=" + sName + ", sAge=" + sAge
+ + "]";
+ }
+}
+cn/hncu/domain/Student.hbm.xml映射文件
+ + + +<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
+"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
+
+<hibernate-mapping package="cn.hncu.domain">
+
+ <!--name指的是POJO类的类名，table是数据库的表名，catalog是数据库的名称 -->
+ <class name="Student" table="students" catalog="hib">
+ <!--id表示此字段为数据库的主键，这里也可以用property来写，name为Student类的成员变量名，type为类型的包全名 -->
+ <id name="sId" type="java.lang.String">
+ <!--column表示映射的数据库的字段，name表示数据库中字段名，length表示varchar/char型的长度 -->
+ <column name="sId" length="8"></column>
+ </id>
+ <property name="sName" type="java.lang.String">
+ <column name="sName" length="40" />
+ </property>
+ <property name="sAge" type="java.lang.Integer">
+ <column name="sAge" />
+ </property>
+ </class>
+
+</hibernate-mapping>HibernateSessionFactory
+ + + +package cn.hncu.hib;
+
+import org.hibernate.HibernateException;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.cfg.Configuration;
+
+public class HibernateSessionFactory {
+ private static String configFile = "/hibernate.cfg.xml";
+ private static Configuration config = new Configuration();
+ private static SessionFactory sessionFactory =null;
+
+ private static final ThreadLocal<Session> t = new ThreadLocal<Session>();
+
+ static{
+ try {
+ /*创建一个配置对象，读取配置文件*/
+ config.configure(configFile);
+ /*通过配置对象产生一个会话工厂类*/
+ sessionFactory = config.buildSessionFactory();
+ } catch (HibernateException e) {
+ e.printStackTrace();
+ }
+ }
+
+ public static Session getSession() throws HibernateException{
+ Session session = t.get();
+ if(session == null || !session.isOpen()){
+ if(sessionFactory==null){
+ rebuildSessionFactory();
+ }
+ /*通过会话工厂类产生一个会话实例*/
+ session = (sessionFactory!=null) ? sessionFactory.openSession() : null;
+ t.set(session);
+ }
+ return session;
+ }
+
+ private static void rebuildSessionFactory() {
+ try {
+ config.configure(configFile);
+ sessionFactory = config.buildSessionFactory();
+ } catch (HibernateException e) {
+ e.printStackTrace();
+ }
+ }
+
+ //关闭与数据库的会话
+ public static void closeSession() throws HibernateException{
+ Session session = t.get();
+ t.set(null);
+ if(session!=null){
+ session.close();
+ }
+ }
+}TestHib
+ + + +package cn.hncu;
+
+import java.util.List;
+
+import org.hibernate.Query;
+import org.hibernate.Session;
+import org.hibernate.SessionFactory;
+import org.hibernate.cfg.Configuration;
+
+import cn.hncu.domain.Student;
+import cn.hncu.hib.HibernateSessionFactory;
+
+public class TestHib {
+
+ public static void main(String[] args) {
+ /*创建一个配置对象，读取配置文件*/
+ String configfile="/hibernate.cfg.xml";
+ Configuration config=new Configuration();
+ config.configure(configfile);
+ /*通过配置对象产生一个会话工厂类*/
+ SessionFactory sessionfactory=config.buildSessionFactory();
+ /*通过会话工厂类产生一个会话实例*/
+ Session session=sessionfactory.openSession();
+ /*通过会话产生一个查询对象Query*/
+ Query query=session.createQuery("from Student");
+ /*进行查询返回一个集合List*/
+ List<Student> studs=query.list();
+ for(Student s:studs){
+ System.out.println(s);
+ }
+
+ session = HibernateSessionFactory.getSession();
+ query = session.createQuery("from Student");
+ List<Student> students = query.list();
+ for(Student s: students){
+ System.out.println(s);
+ }
+ }
+}
+测试结果:
+ ++转载请注明出处：http://blog.csdn.net/qq_26525215
+
+本文源自【大学之旅_谙忆的博客】
++ +转载请注明出处：http://blog.csdn.net/qq_26525215
+
+本文源自【大学之旅_谙忆的博客】
昨天刚刚初学Spring3,也许Spring3有点老了哈，不过还是先把3学了再去学习4吧，首先先介绍一下如何去下载Spring的必须包吧。
+(本篇博客适用于初学Spring的朋友)
java spring4现在不推荐使用xml配置文件…
+当然啦，这些知识点在Spring4还是可以用的。
不过我在这里详解的还是Spring3哈，见谅~
+ +下载SpringJAR包/文档:
+ +Spring官网:http://spring.io/
+ +Spring3.2版本以后(JAR/文档)的下载地址：http://repo.springsource.org/libs-release-local/org/springframework/spring/
+（如果无法访问，请准备梯子）
选择一个需要下载的版本进去:
+我选择的是最新的4.3.2版本.
spring-framework-*(版本号).RELEASE-dist.zip 包含了Spring必须的JAR包、DOC文档以及源代码等。
+ +下载完之后解压我们就可以在spring-framework-4.3.2.RELEASE\libs找到需要包和DOC文档以及源代码了。
+ +
由于最新版本的已经提倡基于Java Config和注解的配置，不采用xml配置了，所以，我在这里准备的是Spring3.1.1版本的:
+下载链接:
+https://github.com/chenhaoxiang/Java/blob/master/Spring/spring-framework-3.1.1.RELEASE.zip
Spring开源框架
+ + + +Spring框架的起始:
+ +Spring在英语中含义就是”春天”.
+对于Java EE开发者来说，Spring框架出现确实带来了一股全新的春天的气息。
+早在2002年，Rod Johson在其编著的《Expert one to one J2EE design and development》书中，对Java EE框架臃肿、低效、脱离现实的种种现状提出了很多质疑，并积极寻求探索革新之道。
+由他主导编写了interface21框架，从实际需求出发，着眼于轻便、灵巧，易于开发、测试和部署的轻量级开发框架。以interface21框架为基础，并集成了其它许多开源成果，于2004年3月24日，发布了1.0正式版取名为Spring。
Spring框架模块：
+ +Spring的核心是个轻量级容器，实现了IoC（控制翻转）模式的容器，基于此核心容器所建立的应用程序，可以达到程序组件的松散耦合。这些特性都使得整个应用程序维护简化。 Spring框架核心由下图所示的七个模块组成。
+ +
现在来分别介绍一下这七个模块:
+ + + +1、核心容器(Core)
+ +这是Spring框架最基础的部分，它提供了依赖注入（Dependency Injection）特征来实现容器对Bean的管理。这里最基本的概念是BeanFactory，它是任何Spring应用的核心。BeanFactory是工厂模式的一个实现，它使用IoC将应用配置和依赖说明从实际的应用代码中分离出来。
+ + + +2、AOP模块
+ +AOP即面向切面编程技术，Spring在它的AOP模块中提供了对面向切面编程的丰富支持。AOP允许通过分离应用的业务逻辑与系统级服务（例如安全和事务管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责其它的系统级关注点，例如日志或事务支持。
+ + + +3、对象/关系映射集成模块ORM
+ +Hibernate是成熟的ORM产品，Spring并没有自己实现ORM框架而是集成了几个流行的ORM产品如Hibernate、JDO和iBATIS等。可以利用Spring对这些模块提供事务支持等。
+ + + +4、JDBC抽象和DAO模块
+ +Spring虽然集成了几个ORM产品，但也可以不选择这几款产品，因为Spring提供了JDBC和DAO模块。该模块对现有的JDBC技术进行了优化。你可以保持你的数据库访问代码干净简洁，并且可以防止因关闭数据库资源失败而引起的问题。
+ +[JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构管管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。SpringDAO的面向JDBC的异常遵从从通用的DAO异常层次结构]
+ +5、Spring的Web模块
+ +Web上下文模块建立于应用上下文模块之上，提供了一个适合于Web应用的上下文。另外，这个模块还提供了一些面向服务支持。例如：实现文件上传的multipart请求，它也提供了Spring和其它Web框架的集成，比如Struts、WebWork。
+ + + +6、应用上下文（Context）模块
+ +核心模块的BeanFactory使Spring成为一个容器，而上下文模块使它成为一个框架。Web上下文模块建立于应用上下文模块之上，提供了一个适合于Web应用的上下文。该模块还提供了一些面向服务支持这个模块扩展了BeanFactory的概念，增加了对国际化（I18N）消息、事件传播以及验证的支持。
+ +另外，这个模块还提供了许多企业服务，例如电子邮件、JNDI访问、EJB集成、远程以及时序调度（scheduling）服务。也包括对模版框架例如Velocity和FreeMarker集成的支持。
+ +7、Spring的MVC框架
+ +Spring为构建Web应用提供了一个功能全面的MVC框架。虽然Spring可以很容易地与其它MVC框架集成，例如Struts2，但Spring的MVC框架使用IoC对控制逻辑和业务对象提供了完全的分离。
+ + + +Spring入门示例
+ +将需要的Jar包导入项目、
+ +再准备一个xml配置文件:
+applicationContext.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%20http://www.springframework.org/schema/beans/spring-beans-3.0.xsd+%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20http://www.springframework.org/schema/context%20http://www.springframework.org/schema/context/spring-context-3.0.xsd+%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20http://www.springframework.org/schema/tx%20http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
+
+</beans>
+将Spring的压缩包解压后：你可以在spring-framework-3.1.1.RELEASE\projects\org.springframework.web.portlet\src\test\java\org\springframework\web\portlet\context\WEB-INF目录下找到applicationContext.xml。我们只需要这个部分就可以了。
+将文件建立在src目录下(建在另外的路径也可以)。
导入必须的包，和建好applicationContext.xml文件。
+ +1、编写一个普通的Java类（JavaBean）
+ + + +package cn.hncu.demo1.domain;
+
+public class Person {
+ private String name;
+ private int age;
+
+ public Person() {
+ System.out.println("执行Person的构造方法....");
+ }
+
+ 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;
+ }
+
+ @Override
+ public String toString() {
+ return "Person [name=" + name + ", age=" + age + "]";
+ }
+}
+2、在Spring配置文件applicationContext.xml。将JavaBean由Spring容器来管理。
+ + + +<beans ...>
+<!--scope属性值设为:prototype(每次获取都是一个新对象), request(同一个request中获取到的是同一个), session ,不设置，默认是单例 -->
+ <bean id="p" class="cn.hncu.demo1.domain.Person" scope="prototype">
+ </bean>
+</beans>测试方法:
+ + + + @Test
+ public void demo1(){
+ //此方法已在3.0版本中过时，不建议使用
+ //BeanFactory factory = new XmlBeanFactory(new ClassPathResource("applicationContext.xml"));
+
+ //Spring3.0建议采用下面这种方式使用容器
+ ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
+ Person p = (Person) ctx.getBean("p");//通过配置的id获得，需要强转
+ System.out.println(p);
+
+ Person p2 = ctx.getBean(Person.class);//通过Person的Class对象去获得，不需要强转
+ System.out.println(p2);
+ }输出结果:
+ +
显然，Person只构造了一次。
+由于我们没给初值，所以name是null，age因为是int型，所以是0.
现在我们在applicationContext.xml中来给它配置好初值，然后看:
+ + <!--scope属性值设为:prototype(每次获取都是一个新对象), request(同一个request中获取到的是同一个), session ,不设置，默认是单例 -->
+ <bean id="p" class="cn.hncu.demo1.domain.Person">
+ <!-- 配置好初始值 -->
+ <property name="name" value="张三"></property>
+ <property name="age" value="23"></property>
+ </bean>再一次的运行结果:
+ +
演示依赖(XML)注入
+ +在servlet注入servicce，Person，
+在servicce注入dao，
LoginDAO
+ + + +package cn.hncu.demo1.login.dao;
+
+import cn.hncu.demo1.domain.Person;
+
+public interface LoginDAO {
+ public void login(Person p);
+}
+LoginDaoJdbc
+ + + +package cn.hncu.demo1.login.dao;
+
+import cn.hncu.demo1.domain.Person;
+
+public class LoginDaoJdbc implements LoginDAO{
+
+ @Override
+ public void login(Person p) {
+ System.out.println("dao,到数据库中读取用户信息以进行登录....");
+ System.out.println("dao中获取的用户输入信息:"+p);
+ }
+
+}
+ILoginService
+ + + +package cn.hncu.demo1.login.service;
+
+import cn.hncu.demo1.domain.Person;
+
+public interface ILoginService {
+
+ public void login(Person p);
+
+}
+LoginServiceImpl
+ + + +package cn.hncu.demo1.login.service;
+
+import cn.hncu.demo1.domain.Person;
+import cn.hncu.demo1.login.dao.LoginDAO;
+
+
+public class LoginServiceImpl implements ILoginService{
+ private LoginDAO dao = null;
+ //如果要注入，需要注入的成员变量，必须写好set-get方法！
+
+ public LoginDAO getDao() {
+ return dao;
+ }
+ public void setDao(LoginDAO dao) {
+ this.dao = dao;
+ }
+
+ @Override
+ public void login(Person p) {
+ dao.login(p);
+ }
+
+}
+LoginAction
+ + + +package cn.hncu.demo1.login;
+
+import cn.hncu.demo1.domain.Person;
+import cn.hncu.demo1.login.service.ILoginService;
+
+public class LoginAction {
+ private ILoginService service = null;
+ private Person p = null;
+ //如果要注入，需要注入的成员变量，必须写好set-get方法！
+ public ILoginService getService() {
+ return service;
+ }
+ public void setService(ILoginService service) {
+ this.service = service;
+ }
+ public Person getP() {
+ return p;
+ }
+ public void setP(Person p) {
+ this.p = p;
+ }
+
+ public void execute(){
+ service.login(p);
+ }
+
+}
+需要依赖注入的变量一定要写好setter-getter 方法哦！！！
+ + + +测试方法:
+ + + +@Test//演示依赖(XML)注入
+ public void demo2(){
+ ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
+ LoginAction action = ctx.getBean(LoginAction.class);
+ //LoginAction action = ctx.getBean("login",LoginAction.class);
+ action.execute();
+ }
+配置文件:
+ + + +<beans ...>
+<!--scope属性值设为:prototype(每次获取都是一个新对象), request(同一个request中获取到的是同一个), session ,不设置，默认是单例 -->
+ <bean id="p" class="cn.hncu.demo1.domain.Person">
+ <!-- 配置好初始值 -->
+ <property name="name" value="张三"></property>
+ <property name="age" value="23"></property>
+ </bean>
+
+ <!-- 注意这里的class是实现类，而不是接口哦 -->
+ <bean id="dao" class="cn.hncu.demo1.login.dao.LoginDaoJdbc">
+ </bean>
+
+ <!-- 注意这里的class也是实现类，而不是接口哦 -->
+ <!-- 如果换实现类了，只需把这里的class变了就可以了 -->
+ <bean id="s" class="cn.hncu.demo1.login.service.LoginServiceImpl">
+ <!-- 实现类中还有变量，ref是另外的bean的id-引用 -->
+ <property name="dao" ref="dao"></property>
+ </bean>
+
+ <bean id="login" class="cn.hncu.demo1.login.LoginAction">
+ <property name="service" ref="s"></property>
+ <property name="person" ref="p"></property>
+ </bean>
+</beans>结构图：
+ +
运行测试方法后的输出结果:
+ +
现在增加一个DAO的实现类，可以在程序中无需代码改变，就可以注入不同实例.
+我们只需要改applicationContext.xml：
<!-- 注意这里的class是实现类，而不是接口哦 -->
+ <!-- 如果换实现类了，只需把这里的class变了就可以了,或者不动这里，增加一个bean -->
+ <bean id="dao" class="cn.hncu.demo1.login.dao.LoginDaoJdbc2">
+ </bean>增加的DAO实现类：
+ + + +package cn.hncu.demo1.login.dao;
+
+import cn.hncu.demo1.domain.Person;
+
+public class LoginDaoJdbc2 implements LoginDAO{
+
+ @Override
+ public void login(Person p) {
+ System.out.println("dao2,到数据库中读取用户信息以进行登录....");
+ System.out.println("dao2中获取的用户输入信息:"+p);
+ }
+
+}
+改动后的演示结果:
+ +
Spring IOC 控制反转
+ +IoC(Inversion of Control)中文译为控制反转也可以叫做DI（Dependency Injection，依赖注入）。
+ +控制反转模式的基本概念是：不直接创建对象，但是在xml配置文件中描述创建它们的方式。
+在工程中使用该Bean时由Spring容器创建Bean的实例。在代码中不直接与对象和服务连接，但在配置文件中描述哪一个组件需要哪一项服务。
1、Spring注入(又称依赖注入DI):
+ +其目的是为其中bean的属性赋值
+ +通过Setter方法。（一般属性赋值即基本类型赋值示例）
+ +第1步：编写JavaBean-必须写set方法
+ +package cn.hncu.demo2.domain;
+
+public class Cat {
+ private String name;
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ @Override
+ public String toString() {
+ return "Cat [name=" + name + "]";
+ }
+
+}
+第2步: 在配置文件中注入属性的初始值
+ + + +<?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%20http://www.springframework.org/schema/beans/spring-beans-3.0.xsd+%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20http://www.springframework.org/schema/context%20http://www.springframework.org/schema/context/spring-context-3.0.xsd+%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20http://www.springframework.org/schema/tx%20http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
+
+ <bean id="cat" class="cn.hncu.demo2.domain.Cat">
+ <!-- 初始化name -->
+ <property name="name" value="黑猫"></property>
+ </bean>
+
+</beans>
+这样拿到的Cat对象就有初始值了，name的初始值为”黑猫”。
+ + + +复杂数据类型的初始化：
+ +例如，含有List，Map，Set，或者其他对象的数据，这样的bean对象如何初始化值呢。
+ +结构如下:
+ +
Cat类就是前面那个。
+ + + +User
+ + + +package cn.hncu.demo2.domain;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class User {
+ private String name;
+ private Integer age;
+ private List<Object> pets;
+ private Map<String, Object> map;
+ private Set<Object> set;
+ private Object objs[];
+ private Cat cat;
+
+
+ public String getName() {
+ return name;
+ }
+
+ public void setName(String name) {
+ this.name = name;
+ }
+
+ public Integer getAge() {
+ return age;
+ }
+
+ public void setAge(Integer age) {
+ this.age = age;
+ }
+
+
+ public List<Object> getPets() {
+ return pets;
+ }
+
+ public void setPets(List<Object> pets) {
+ this.pets = pets;
+ }
+
+
+ public Map<String, Object> getMap() {
+ return map;
+ }
+
+ public void setMap(Map<String, Object> map) {
+ this.map = map;
+ }
+
+
+
+ public Set<Object> getSet() {
+ return set;
+ }
+
+ public void setSet(Set<Object> set) {
+ this.set = set;
+ }
+
+
+
+ public Object[] getObjs() {
+ return objs;
+ }
+
+ public void setObjs(Object[] objs) {
+ this.objs = objs;
+ }
+
+ public Cat getCat() {
+ return cat;
+ }
+
+ public void setCat(Cat cat) {
+ this.cat = cat;
+ }
+
+ @Override
+ public String toString() {
+ return "User [name=" + name + ", age=" + age + ", pets=" + pets
+ + "\r\n map=" + map + "\r\n set=" + set + "\r\n objs="
+ + Arrays.toString(objs) + ", cat=" + cat + "]";
+ }
+
+}
+配置文件
+ +在这里我取名为：applicationContext2.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%20http://www.springframework.org/schema/beans/spring-beans-3.0.xsd+%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20http://www.springframework.org/schema/context%20http://www.springframework.org/schema/context/spring-context-3.0.xsd+%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20http://www.springframework.org/schema/tx%20http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">
+
+
+ <bean id="cat" class="cn.hncu.demo2.domain.Cat">
+ <!-- 初始化name -->
+ <property name="name" value="黑猫"></property>
+ </bean>
+
+ <bean id="user" class="cn.hncu.demo2.domain.User">
+ <property name="name" value="Jack"></property>
+ <property name="age" value="25"></property>
+
+ <property name="pets">
+ <list>
+ <value>cat</value>
+ <value>dog</value>
+ <value>tiger</value>
+ </list>
+ </property>
+
+ <property name="map">
+ <map>
+ <entry key="name" value="中国"></entry>
+ <entry key="age" value="67"></entry>
+ <!-- ref是引用 -->
+ <entry key="cat" value-ref="cat"></entry>
+ </map>
+ </property>
+ <property name="set">
+ <set>
+ <!-- 引用 -->
+ <ref bean="cat"/>
+ <value>aaa</value>
+ <value>bbb</value>
+ </set>
+ </property>
+ <property name="objs">
+ <!-- 数组 -->
+ <array>
+ <value>hrllo</value>
+ <ref bean="cat"/>
+ <list>
+ <value>obj1</value>
+ <value>obj2</value>
+ </list>
+ <bean class="cn.hncu.demo2.domain.Cat">
+ <property name="name" value="白猫"></property>
+ </bean>
+ </array>
+ </property>
+ </bean>
+</beans>
+测试类:
+ + + +package cn.hncu.demo2;
+
+import org.junit.Test;
+import org.springframework.context.ApplicationContext;
+import org.springframework.context.support.ClassPathXmlApplicationContext;
+
+import cn.hncu.demo2.domain.User;
+
+public class Demo2 {
+
+ //演示spring中<bean>属性注入的一些细节
+ @Test
+ public void demo(){
+ ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext2.xml");
+ User user = ctx.getBean("user",User.class);
+ System.out.println(user);
+ }
+
+
+}
+测试结果:
+ +
如果对于这个User的类的赋值搞懂了，我想应该在这块就会很熟练了。
+ + + +完整的项目源码:
+ +本文章由[谙忆]编写， 所有权利保留。
+ ++转载请注明出处：http://blog.csdn.net/qq_26525215
+
+本文源自【大学之旅_谙忆的博客】
-
+
-
+
-
+
-
+