菜鸟学习Spring——SpringIoC容器基于三种配置的对比
最后更新于：2022-04-01 09:34:25
## 一、概述
对于实现Bean信息定义的目标，它提供了基于XML、基于注解及基于java类这三种选项。下面总结一下三种配置方式的差异。
## 二、Bean不同配置方式比较。
## 三、Bean不同配置方式的适用场合。
## 四、总结。
一般我们适用XML配置DataSource、SessionFactory等资源的Bean，在XML中利用aop、context命名空间进行主题的配置。其他所有项目中开发的Bean用注解的形式来配置。这就是采用了“XML+基于配置”的配置方式，很少采用基于Java类的配置方式。
Spring不仅提供了三种实现的方案还允许多项自由组合，让三种方式取长补短最终达到本质是一样的。
菜鸟学习Spring——SpringMVC注解版解析不同格式的JSON串
最后更新于：2022-04-01 09:34:22
## 一、概述
不同格式的JSON串传到后台来实现功能这个是我们经常要做的一件事，本篇博客就给大家介绍四种不同的JSON串传到后台后台如何用@RequestBody解析这些不同格式的JSON串的。
## 二、代码展示
需要引用的jar包
1.xml配置
Web.xml
~~~
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
<servlet>
<servlet-name>springMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springMVC</servlet-name>
<url-pattern>*.spring</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
~~~
springMVC-servlet.xml
~~~
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">
<context:component-scan base-package="com.gaowei.JSON" />
<mvc:annotation-driven />
</beans>
~~~
2.java代码
Userinfo.java
~~~
package com.gaowei.entity;
public class Userinfo {
private String username;
private String password;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
~~~
Test.java
~~~
package com.gaowei.JSON;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import com.gaowei.entity.Userinfo;
@Controller
public class Test {
@RequestMapping(value="getJSON1")
public void getJSON1(@RequestBody Userinfo userinfo){
System.out.println("------getJSON1---start----");
System.out.println(userinfo.getUsername());
System.out.println(userinfo.getPassword());
System.out.println("------getJSON1---end----");
}
@RequestMapping(value="getJSON2")
public void getJSON2(@RequestBody ArrayList<String> list){
System.out.println("------getJSON2---start----");
for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}
System.out.println("------getJSON2---end----");
}
@RequestMapping(value="getJSON3")
public void getJSON3(@RequestBody List<Map> list){
System.out.println("------getJSON3---start----");
for (int i = 0; i < list.size(); i++) {
Map map=list.get(i);
System.out.println(map.get("username")+" "+map.get("password"));
}
System.out.println("------getJSON3---end----");
}
@RequestMapping(value="getJSON4")
public void getJSON4(@RequestBody Map map){
System.out.println("------getJSON4---start----");
System.out.println(map.get("username"));
List<Map> workList=(List)map.get("work");
for (int i = 0; i < workList.size(); i++) {
Map eachAddressMap=workList.get(i);
System.out.println("address="+eachAddressMap.get("address"));
}
Map schoolMap=(Map)map.get("school");
System.out.println(schoolMap.get("name"));
System.out.println(schoolMap.get("address"));
System.out.println("------getJSON4---end----");
}
}
~~~
3.界面代码
Test.jsp
~~~
<%@ page language="java" import="java.util.*" pageEncoding="utf-8" %>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<script src="jquery-1.3.2.js">
</script>
<script src="json2.js">
</script>
<script>
function userinfo(username, password){
this.username = username;
this.password = password;
}
function sendAjax1(){
var userinfoRef = new userinfo('中国', '中国人');
var jsonStringRef = JSON.stringify(userinfoRef);
$.ajax({
type: "POST",
data: jsonStringRef,
url: "getJSON1.spring?t=" + new Date().getTime(),
contentType: "application/json"
});
}
function sendAjax2(){
var myArray =new Array();
myArray[0]="中国1";
myArray[1]="中国2";
myArray[2]="中国3";
myArray[3]="中国4";
var jsonString=JSON.stringify(myArray);
$.ajax({
type: "POST",
data: jsonString,
url: "getJSON2.spring?t=" + new Date().getTime(),
contentType: "application/json"
});
}
function sendAjax3(){
var myArray=new Array();
myArray[0]= new userinfo('中国1', '中国人1');
myArray[1]= new userinfo('中国2', '中国人2');
myArray[2]= new userinfo('中国3', '中国人3');
myArray[3]= new userinfo('中国4', '中国人4');
var jsonString=JSON.stringify(myArray);
$.ajax({
type: "POST",
data: jsonString,
url: "getJSON3.spring?t=" + new Date().getTime(),
contentType: "application/json"
});
}
function sendAjax4(){
var jsonObject={
"username":"accp",
"work":[{
"address":"address1"
},{
"address":"address2"
}],
"school":{
"name":"tc",
"address":"pjy"
}
}
var jsonString=JSON.stringify(jsonObject);
$.ajax({
type: "POST",
data: jsonString,
url: "getJSON4.spring?t=" + new Date().getTime(),
contentType: "application/json"
});
}
</script>
</head>
<body>
<input type="button" onclick="sendAjax1()" value="sendAjax1"/>
<br/>
<input type="button" onclick="sendAjax2()" value="sendAjax2">
<br/>
<input type="button" onclick="sendAjax3()" value="sendAjax3">
<br/>
<input type="button" onclick="sendAjax4()" value="sendAjax4">
<br/>
</body>
</html>
~~~
4.效果图
## 三、总结。
这里要注意jar包的引用不要把Spring的所有jar包都引用了会引起jar包冲突而导致报HTTP415的错误。@RequestBody这个方法很强大可以把JSON串转化为实体类、ArryList、Map等对象。这样的方法让我们开发人员开发效率大大的提高了
菜鸟学习Spring——SpringMVC注解版将URL中的参数转成实体
最后更新于：2022-04-01 09:34:20
## 一、概述
将URL中参数转成实体在我们项目中用的很多比如界面提交表单请求后台的Contorller的时候通过URL传递了一串参数到后台，后台通过Spring让界面的字段与实体的字段映射来实现给后台的实体属性赋值。
## 二、代码演示。
2.1 web.xml
~~~
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
id="WebApp_ID" version="3.1">
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<servlet>
<servlet-name>springMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springMVC</servlet-name>
<url-pattern>*.spring</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
~~~
2.2springMVC-servlet.xml
~~~
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">
<context:component-scan base-package="com.gaowei.ParamToObject" />
</beans>
~~~
2.3test.jsp
~~~
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<form action="paramToEntity.spring" method="POST">
username:
<input type="text" name="username">
<br/>
password:
<input type="text" name="password">
<br/>
<input type="submit" name="submit">
<br/>
</form>
</body>
</html>
~~~
2.4后台代码。
Userinfo.java
~~~
package com.gaowei.entity;
public class Userinfo {
private String username;
private String password;
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
}
~~~
ParamToEntity.java
~~~
package com.gaowei.ParamToObject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import com.gaowei.entity.Userinfo;
@Controller
public class ParamToEntity {
@RequestMapping(value="paramToEntity",method=RequestMethod.POST)
public String paramToEntity(Userinfo userinfo){
System.out.println("username value="+userinfo.getUsername());
System.out.println("password value="+userinfo.getPassword());
return "test.jsp";
}
}
~~~
2.5效果图。
## 三、总结。
前台向后台传递数据有很多种方式，我们可以根据不同的情况用不同的方法这也让我意识到以后我们要开发框架的时候要给使用者提供很多不同的方式来对应不同的情况。
菜鸟学习Spring——SpringMVC注解版在服务器端获取Json字符串并解析
最后更新于：2022-04-01 09:34:18
## 一、概述。
SpringMVC在服务端把客户端传过来的JSON字符串，并把JSON字符串转成 JSON对象并取得其中的属性值，这个在项目中经常用到。
## 二、代码演示。
需要添加的jar包。
2.1 web.xml。
~~~
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://xmlns.jcp.org/xml/ns/javaee"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
id="WebApp_ID" version="3.1">
<filter>
<filter-name>encodingFilter</filter-name>
<filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
<init-param>
<param-name>encoding</param-name>
<param-value>utf-8</param-value>
</init-param>
</filter>
<filter-mapping>
<filter-name>encodingFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
<servlet>
<servlet-name>springMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springMVC</servlet-name>
<url-pattern>*.spring</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
~~~
2.2springMVC-servlet.xml。
~~~
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p" xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd
http://www.springframework.org/schema/mvc
http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd">
<context:component-scan base-package="com.gaowei.JSON" />
<mvc:annotation-driven />
</beans>
~~~
2.3 JSP文件。
~~~
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
<script type="text/javascript" src="jquery-1.3.2.js">
</script>
<script type="text/javascript" src="json2.js">
</script>
<script type="text/javascript">
function userinfo(username,password){
this.username=username;
this.password=password;
}
function sendAjax(){
var userinfoRef=new userinfo('高玮','12312');
var jsonStringRef=JSON.stringify(userinfoRef);
$.post("getJSONString.spring?t="+new Date().getTime(),{
jsonString:jsonStringRef
});
}
</script>
</head>
<body>
<input type="button" onclick="sendAjax()" value="登录" >
</body>
</html>
~~~
2.4GetJSONString.java。
~~~
package com.gaowei.JSON;
import net.sf.json.JSONObject;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
public class GetJSONString {
@RequestMapping(value="getJSONString")
public String getJSONString(@RequestParam("jsonString") String jsonString){
JSONObject object=JSONObject.fromObject(jsonString);
System.out.println(object.get("username"));
System.out.println(object.get("password"));
return "test.jsp";
}
}
~~~
2.5效果图。
## 三、总结
页面与Contorller层的交互避免要用到JSON传值到后台，这中方法就可以让我们更好的实现界面层与Contorller的交互。
菜鸟学习Spring——SpringMVC注解版前台向后台传值的两种方式
最后更新于：2022-04-01 09:34:16
## 一、概述。
在很多企业的开法中常常用到SpringMVC+Spring+Hibernate（mybatis）这样的架构，SpringMVC相当于Struts是页面到Contorller直接的交互的框架也是界面把信息传输到Contorller层的一种架构，通过这个架构可以让我们把页面和Contorller层解耦，使得开发人员的分工更加明确。
## 二、代码演示。
1、首先配置SpringMVC环境。
1.1导入jar。
值得注意的是红色标记的commons-logging这个jar包一定得引入进去不然会报错。
1.2、xml配置文件。
web.xml
~~~
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd" id="WebApp_ID" version="3.1">
<servlet>
<servlet-name>springMVC</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springMVC</servlet-name>
<url-pattern>*.spring</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>
~~~
springMVC-servlet.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:p="http://www.springframework.org/schema/p"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:component-scan base-package="com.gaowei.controller" />
</beans>
~~~
2、前台界面代码。
login.jsp
~~~
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
<form action="login.spring" method="post">
username:<input type="text" name="username">
<br/>
password:<input type="text" name="password">
<br/>
<input type="submit" value="登录">
</form>
</body>
</html>
~~~
No.jsp
~~~
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
No!
</body>
</html>
~~~
Ok.jsp
~~~
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
OK！ welcome:${username}
</body>
</html>
~~~
3、Contorller层接收前台的两种方式。
方式一：
利用@RequestParam这个注解
~~~
package com.gaowei.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
public class Login {
//方式一
@RequestMapping("/login")
public String login(@RequestParam("username") String username,
@RequestParam("password") String password,Model model){
if (username.equals(password))
{
model.addAttribute("username", username);
return "ok.jsp";
} else {
return "no.jsp";
}
}
}
~~~
方式二：
~~~
package com.gaowei.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
@Controller
public class Login {
@RequestMapping("/login")
public String login(String username,String password,Model model){
if (username.equals(password))
{
model.addAttribute("username", username);
return "ok.jsp";
} else {
return "no.jsp";
}
}
}
~~~
4、界面结果。
第一种传值方式：
第二种传值方式：
> 
## 三、总结。
这里体现出了SpringMVC传值方式的多样性满足了开发人员的不同需求。第一种用来表单的提交。第二种用来界面间相互传值，也为了方便开发人员利用AJAX。
菜鸟学习SSH——目录
最后更新于：2022-04-01 09:34:13
1. [菜鸟学习Struts——配置Struts环境](http://blog.csdn.net/gwblue/article/details/18367901)
1. [菜鸟学习Struts——简易计算器](http://blog.csdn.net/gwblue/article/details/18400145)
1. [菜鸟学习Struts——bean标签库](http://blog.csdn.net/gwblue/article/details/20059603)
1. [菜鸟学习Struts——Scope属性](http://blog.csdn.net/gwblue/article/details/21039079)
1. [菜鸟学习Struts——国际化](http://blog.csdn.net/gwblue/article/details/21550737)
1. [菜鸟学习Struts——总结](http://blog.csdn.net/gwblue/article/details/22385887)
1. [菜鸟学习Hibernate——配置Hibernate环境](http://blog.csdn.net/gwblue/article/details/22691335)
1. [菜鸟学习Hibernate——持久层框架](http://blog.csdn.net/gwblue/article/details/23305717)
1. [菜鸟学习Hibernate——简单的一个例子](http://blog.csdn.net/gwblue/article/details/24017761)
1. [菜鸟学习Hibernate——简单的增、删、改、查操作](http://blog.csdn.net/gwblue/article/details/24593113)
1. [菜鸟学习Hibernate——一对多关系映射](http://blog.csdn.net/gwblue/article/details/26486423)
1. [菜鸟学习Hibernate——多对多关系映射](http://blog.csdn.net/gwblue/article/details/35787135)
1. [菜鸟学习Hibernate——缓存](http://blog.csdn.net/gwblue/article/details/35787549)
1. [菜鸟学习Spring——初识Spring](http://blog.csdn.net/gwblue/article/details/39610111)
1. [菜鸟学习Spring——第一个例子](http://blog.csdn.net/gwblue/article/details/39610149)
1. [60s让你学会动态代理原理](http://blog.csdn.net/gwblue/article/details/39668211)
1. [菜鸟学习Spring——60s使用annotation实现简单AOP](http://blog.csdn.net/gwblue/article/details/40298263)
1. [菜鸟学习Spring——60s配置XML方法实现简单AOP](http://blog.csdn.net/gwblue/article/details/40507095)
1. [菜鸟学习Spring——60s利用JoinPoint获取参数的值和方法名称](http://blog.csdn.net/gwblue/article/details/40592117)
1. [菜鸟学习Spring——60s学会Spring与Hibernate的集成](http://blog.csdn.net/gwblue/article/details/40630483)
菜鸟学习Spring——60s学会Spring与Hibernate的集成
最后更新于：2022-04-01 09:34:11
## 一、概述。
Spring与Hibernate的集成在企业应用中是很常用的做法通过Spring和Hibernate的结合能提高我们代码的灵活性和开发效率,下面我就一步一步的给大家讲述Spring如何和Hibernate集成的。
## 二、代码演示。
导入Hibernate的jar包
Hibernate-3.2/lib/*.jarHibernate-3.2/hibernate3.jar
还有导入Spring的相关jar包我用的数据库是MySql所以要导入MySql的驱动jar包：
mysql-connector-java-3.1.13-bin.jar
目录结构:
Hibernate的实体映射:
Log.java
~~~
package com.tgb.usermgr.domain;
import java.util.Date;
public class Log {
private int id;
private String type;
private String detail;
private Date time;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public String getDetail() {
return detail;
}
public void setDetail(String detail) {
this.detail = detail;
}
public Date getTime() {
return time;
}
public void setTime(Date time) {
this.time = time;
}
}
~~~
User.java
~~~
package com.tgb.usermgr.domain;
public class User {
private int id;
private String name;
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;
}
}
~~~
Log.hbm.xml
~~~
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.tgb.usermgr.domain.Log" table="t_log">
<id name="id">
<generator class="native"/>
</id>
<property name="type"/>
<property name="detail"/>
<property name="time"/>
</class>
</hibernate-mapping>
~~~
User.hbm.xml
~~~
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.tgb.usermgr.domain.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
</class>
</hibernate-mapping>
~~~
Hibernate的工具类
HibernateUtils.java
~~~
package com.tgb.usermgr.util;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtils {
private static SessionFactory factory;
private HibernateUtils() {
}
static {
try {
Configuration cfg = new Configuration().configure();
factory = cfg.buildSessionFactory();
}catch(Exception e) {
e.printStackTrace();
throw new java.lang.RuntimeException(e);
}
}
public static SessionFactory getSessionFactory() {
return factory;
}
public static Session getSession() {
return factory.openSession();
}
public static void closeSession(Session session) {
if (session != null) {
if (session.isOpen()) {
session.close();
}
}
}
}
~~~
业务逻辑实现和接口：
LogManager.java
~~~
package com.tgb.usermgr.manager;
import com.tgb.usermgr.domain.Log;
public interface LogManager {
public void addLog(Log log);
}
~~~
LogManagerImpl.java
~~~
package com.tgb.usermgr.manager;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.tgb.usermgr.domain.Log;
import com.tgb.usermgr.util.HibernateUtils;
public class LogManagerImpl extends HibernateDaoSupport implements LogManager {
public void addLog(Log log) {
//getSession().save(log);
getHibernateTemplate().save(log);
}
}
~~~
UserManager.java
~~~
package com.tgb.usermgr.manager;
import com.tgb.usermgr.domain.User;
public interface UserManager {
public void addUser(User user) throws Exception;
}
~~~
UserManagerImpl.java
~~~
package com.tgb.usermgr.manager;
import java.util.Date;
import org.hibernate.Session;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import com.tgb.usermgr.domain.Log;
import com.tgb.usermgr.domain.User;
import com.tgb.usermgr.util.HibernateUtils;
public class UserManagerImpl extends HibernateDaoSupport implements UserManager {
private LogManager logManager;
public void addUser(User user)
throws Exception {
//this.getSession().save(user);
this.getHibernateTemplate().save(user);
Log log = new Log();
log.setType("操作日志");
log.setTime(new Date());
log.setDetail("XXX");
logManager.addLog(log);
throw new Exception();
}
public void setLogManager(LogManager logManager) {
this.logManager = logManager;
}
}
~~~
客户端的测试类：
UserManagerImplTest.java
~~~
package com.tgb.usermgr.manager;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tgb.usermgr.domain.User;
import junit.framework.TestCase;
public class UserManagerImplTest extends TestCase {
public void testAddUser() {
BeanFactory factory = new ClassPathXmlApplicationContext("applicationContext-*.xml");
UserManager userManager = (UserManager)factory.getBean("userManager");
User user = new User();
user.setName("张三");
try {
userManager.addUser(user);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
~~~
配置文件：
hibernate.cfg.xml
~~~
<!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="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost/spring_hibernate_2</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.show_sql">true</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<mapping resource="com/tgb/usermgr/domain/User.hbm.xml"/>
<mapping resource="com/tgb/usermgr/domain/Log.hbm.xml"/>
</session-factory>
</hibernate-configuration>
~~~
applicationContext-common.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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
<!-- 配置SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
</bean>
<!-- 配置事务管理器 -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory"/>
</property>
</bean>
<!-- 那些类那些方法使用事务 -->
<aop:config>
<aop:pointcut id="allManagerMethod" expression="execution(* com.tgb.usermgr.manager.*.*(..))"/>
<aop:advisor pointcut-ref="allManagerMethod" advice-ref="txAdvice"/>
</aop:config>
<!-- 事务的传播特性 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="add*" propagation="REQUIRED"/>
<tx:method name="del*" propagation="REQUIRED"/>
<tx:method name="modify*" propagation="REQUIRED"/>
<tx:method name="*" propagation="REQUIRED" read-only="true"/>
</tx:attributes>
</tx:advice>
</beans>
~~~
applicationContext-beans.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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
<bean id="userManager" class="com.tgb.usermgr.manager.UserManagerImpl">
<property name="sessionFactory" ref="sessionFactory"/>
<property name="logManager" ref="logManager"/>
</bean>
<bean id="logManager" class="com.tgb.usermgr.manager.LogManagerImpl">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
</beans>
~~~
效果图：
## 三、总结。
Hibernate与Spring的结合使系统变的更加灵活，能应对一定的需求变化。Hibernate解决了我们数据库变换的问题，Spring解决了我们类与类之间变化的问题。不仅让系统变的灵活了而且大大的提高了我们开发人员的开发效率和维护效率。
菜鸟学习Spring——60s利用JoinPoint获取参数的值和方法名称
最后更新于：2022-04-01 09:34:09
## 一、概述
AOP的实现方法在上两篇博客中已经用了两种方法来实现现在的问题来了虽然我们利用AOP，那么客户端如何信息传递？利用JoinPoint接口来实现客户端给具体实现类的传递参数。
## 二、代码演示。
目录结构：
SecurityHandler.java
~~~
package com.tgb.spring;
import org.aspectj.lang.JoinPoint;
public class SecurityHandler{
private void checkSecurity(JoinPoint joinPoint){
for (int i = 0; i < joinPoint.getArgs().length; i++) {
System.out.println(joinPoint.getArgs()[i]);
}
System.out.println(joinPoint.getSignature().getName());
System.out.println("=====checkSecurity====");
}
}
~~~
Client.java
~~~
package com.tgb.spring;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tgb.spring.UserManager;
public class Client {
public static void main(String[] args) {
BeanFactory factory=new ClassPathXmlApplicationContext("applicationContext.xml");
UserManager userManager=(UserManager) factory.getBean("userManager");
userManager.addUser("张三", "123");
//userManager.delUser(1);
}
}
~~~
UserManager.java
~~~
package com.tgb.spring;
public interface UserManager {
public void addUser(String username,String password);
public void delUser(int userId);
public String findUserById(int userId);
public void modifyUser(int userId,String username,String password);
}
~~~
UserManagerImpl.java
~~~
package com.tgb.spring;
public class UserManagerImpl implements UserManager {
public void addUser(String username, String password) {
//checkSecurity();
System.out.println("===UserManager.addUser===");
}
public void delUser(int userId) {
//checkSecurity();
System.out.println("===UserManager.delUser===");
}
public String findUserById(int userId) {
//checkSecurity();
System.out.println("===UserManager.findUserById===");
return "张三";
}
public void modifyUser(int userId, String username, String password) {
//checkSecurity();
System.out.println("===UserManager.modifyUser===");
}
// private void checkSecurity(){
// System.out.println("checkSecurity");
//
// }
}
~~~
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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
<bean id="userManager" class="com.tgb.spring.UserManagerImpl" />
<bean id="securityHandler" class="com.tgb.spring.SecurityHandler"/>
<aop:config>
<aop:aspect id="securityAspect" ref="securityHandler">
<aop:pointcut id="addAddMethod" expression="execution(* com.tgb.spring.*.*(..))" />
<aop:before method="checkSecurity" pointcut-ref="addAddMethod" />
</aop:aspect>
</aop:config>
</beans>
~~~
效果图：
## 三、总结。
我们可以通过Advice中添加一个JoinPoint参数，这个值会由spring自动传入，从JoinPoint中可以取得。
菜鸟学习Spring——60s配置XML方法实现简单AOP
最后更新于：2022-04-01 09:34:06
## 一、概述。
上一篇博客讲述了用注解的形式实现AOP现在讲述另外一种AOP实现的方式利用XML来实现AOP。
## 二、代码演示。
准备工作参照上一篇博客[《菜鸟学习Spring——60s使用annotation实现简单AOP》](http://blog.csdn.net/gwblue/article/details/40298263)
目录结构：
其实比起上一篇博客中用annotation来实现AOP的方式我们只要把SecurityHandler.java和配置文件applicationContext.xml更改为下面内容就可以了。下面我把这两个文件的代码写下来。
SecurityHandler.java
~~~
package com.tgb.spring;
public class SecurityHandler{
private void checkSecurity(){
System.out.println("checkSecurity");
}
}
~~~
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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
<bean id="userManager" class="com.tgb.spring.UserManagerImpl" />
<bean id="securityHandler" class="com.tgb.spring.SecurityHandler"/>
<aop:config>
<aop:aspect id="securityAspect" ref="securityHandler">
<aop:pointcut id="addAddMethod" expression="execution(* com.tgb.spring.*.*(..))" />
<aop:before method="checkSecurity" pointcut-ref="addAddMethod" />
</aop:aspect>
</aop:config>
</beans>
~~~
效果图：
## 三、总结。
XML实现的AOP对代码没有了侵入性并且能够灵活的配置不用重新编译。但是有个缺点就是配置文件太多了不好管理。
菜鸟学习Spring——60s使用annotation实现简单AOP
最后更新于：2022-04-01 09:34:04
## 一、概述。
AOP大家都知道切面编程，在Spring中annotation可以实现简单的AOP列子。下面还未大家介绍几个概念：
Aspect
对横切性关注点的模块化。
Advice
对横切性关注点的具体实现。
Pointcut
它定义了Advice应用到哪些JoinPoint上，对Spring来说是方法调用。
JoinPoint
Advice在应用程序上执行的点或时机，Spring只支持方法的JoinPoint，这个点也可以使属性修改，如：Aspecj可以支持。
Weave
将Advice应用到Target Object上的过程叫织入，Spring支持的是动态织入。
Target Object
Advice被应用的对象。
Proxy
Spring AOP默认使用JDK的动态代理，它的代理是运行时创建，也可以使用CGLIB代理。
## 二、代码演示。
为了实现使用annotation实现简单AOP我们还得加入下面几个包:
SPRING_HOME/lib/aspectj/*.jar
目录结构：
UserManager.java和UserManagerImpl.java代码参照
[http://blog.csdn.net/gwblue/article/details/39668211](http://blog.csdn.net/gwblue/article/details/39668211)
中的UserManager.java和方法二的UserManagerImpl.java
SecurityHandler.java
~~~
package com.tgb.spring;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
@Aspect
public class SecurityHandler{
/**
*确定需要使用checkSecurity使用方法的范围
*/
@Pointcut("execution(* add*(..))")
private void addAddMethod(){}
/**
*Before是指在执行方法之前运行
*After是只在执行方法之后运行
*/
@Before("addAddMethod()")
private void checkSecurity(){
System.out.println("checkSecurity");
}
}
~~~
Client.java
~~~
package com.tgb.spring;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tgb.spring.UserManager;
public class Client {
public static void main(String[] args) {
BeanFactory factory=new ClassPathXmlApplicationContext("applicationContext.xml");
UserManager userManager=(UserManager) factory.getBean("userManager");
userManager.addUser("张三", "123");
userManager.delUser(1);
}
}
~~~
applcationContext.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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
<!-- 启用AspectJ -->
<aop:aspectj-autoproxy/>
<bean id="userManager" class="com.tgb.spring.UserManagerImpl" />
<bean id="securityHandler" class="com.tgb.spring.SecurityHandler"/>
</beans>
~~~
效果图：
## 三、综述。
利用annotation方式简单的实现了AOP，注解是一种侵入性比较强的AOP实现方式，它的优点是让开发者更加方便的使用AOP。
菜鸟学习Spring——60s让你学会动态代理原理
最后更新于：2022-04-01 09:34:02
## 一、为什么要使用动态代理
当一个对象或多个对象实现了N中方法的时候，由于业务需求需要把这个对象和多个对象的N个方法加入一个共同的方法，比如把所有对象的所有方法加入事务这个时候有三种方法：
方法一：一个一个对象一个一个方法去加，很显然这个方法是一个比较笨的方法。
方法二：加一个静态代理对象将这个静态代理对象实现要加事务对象的接口。然后在静态代理对象里面每个方法里面加上事务。
方法三：使用动态代理对象，进行动态的加载事务。
使用动态代理是为了让对象实现了开闭原则，对扩展开放，而对修改关闭。Spring的AOP其实就是用了动态代理+IoC容器实现的
二、代码实现。> UserManger.java接口
~~~
package com.tgb.spring;
public interface UserManager {
public void addUser(String username,String password);
public void delUser(int userId);
public String findUserById(int userId);
public void modifyUser(int userId,String username,String password);
}
~~~
方法一 常规的做法：
UserMangerImpl.Java
~~~
package com.tgb.spring;
public class UserManagerImpl implements UserManager {
public void addUser(String username, String password) {
checkSecurity();
System.out.println("UserManager.addUser");
}
public void delUser(int userId) {
checkSecurity();
System.out.println("UserManager.delUser");
}
public String findUserById(int userId) {
checkSecurity();
System.out.println("UserManager.findUserById");
return "张三";
}
public void modifyUser(int userId, String username, String password) {
checkSecurity();
System.out.println("UserManager.modifyUser");
}
private void checkSecurity(){
System.out.println("checkSecurity");
}
}
~~~
Client.java
~~~
package com.tgb.spring;
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
UserManager userManager=new UserManagerImpl();
userManager.addUser("11", "1231");
}
}
~~~
方法二 静态代理：
UserManagerImpl.java
~~~
package com.tgb.spring;
public class UserManagerImpl implements UserManager {
public void addUser(String username, String password) {
//checkSecurity();
System.out.println("UserManager.addUser");
}
public void delUser(int userId) {
//checkSecurity();
System.out.println("UserManager.delUser");
}
public String findUserById(int userId) {
//checkSecurity();
System.out.println("UserManager.findUserById");
return "张三";
}
public void modifyUser(int userId, String username, String password) {
//checkSecurity();
System.out.println("UserManager.modifyUser");
}
// private void checkSecurity(){
// System.out.println("checkSecurity");
//
// }
}
~~~
UserManagerImplProxy.java
~~~
package com.tgb.spring;
public class UserManagerImplProxy implements UserManager {
private UserManager userManager;
public UserManagerImplProxy(UserManager userManager){
this.userManager=userManager;
}
public void addUser(String username, String password) {
// TODO Auto-generated method stub
checkSecurity();
userManager.addUser(username, password);
}
public void delUser(int userId) {
// TODO Auto-generated method stub
checkSecurity();
userManager.delUser(userId);
}
public String findUserById(int userId) {
// TODO Auto-generated method stub
checkSecurity();
return userManager.findUserById(userId);
}
public void modifyUser(int userId, String username, String password) {
// TODO Auto-generated method stub
checkSecurity();
userManager.modifyUser(userId, username, password);
}
private void checkSecurity(){
System.out.println("checkSecurity");
}
}
~~~
Client.java
~~~
package com.tgb.spring;
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
UserManagerImpl uesrMangerImpl=new UserManagerImpl();
UserManager userManager=new UserManagerImplProxy(uesrMangerImpl);
userManager.addUser("11", "1231");
}
}
~~~
方法三：动态代理
UserManagerImpl.java与方法二的UserManagerImpl.java一样把UserManagerImplProxy.java删除
新添一个类：
SecurityHandler.java
~~~
package com.tgb.spring;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class SecurityHandler implements InvocationHandler {
private Object targetObject;
public Object createProxyInstance(Object targetObject){
this.targetObject=targetObject;
return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
targetObject.getClass().getInterfaces(),
this);
}
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// TODO Auto-generated method stub
checkSecurity();
//调用目标方法
Object ret=method.invoke(targetObject, args);
return ret;
}
private void checkSecurity(){
System.out.println("checkSecurity");
}
}
~~~
Client.java
~~~
package com.tgb.spring;
public class Client {
public static void main(String[] args) {
SecurityHandler handler=new SecurityHandler();
UserManager userManager=(UserManager)handler.createProxyInstance(new UserManagerImpl());
userManager.addUser("zha", "123");
}
}
~~~
三种方法的效果是一样的如图：
## 三、总结。
动态代理的利用给我们编码带来了很大的便利，解决了动态为对象提供服务的方案。动态代理+IoC容器的结合让我们对系统提供服务更加的方便了这样我们也就实现了开闭原则。这样也就能实现了对象想要的时候就有不用的时候就撤出全心全意为开发者服务。
菜鸟学习Spring——第一个例子
最后更新于：2022-04-01 09:33:59
## 一、概述
原来我们利用工厂来实现灵活的配置。现在利用Spring以后把这个交给了IoC容器管理。我们只要在XML文件上配上就可以了这样的话就节省了很多开发时间我们不需要知道后面的有多少只要动态的配上类就可以了下面就给大家做一个例子
## 二、代码展示。
文件目录如下图：
需要引用的jar包：
spring.jar
Lib/log4j/log4j.jar
Lib/jakarta-commons/commons-logging.jar
需要引用的文件
Log4j.properties
下面是代码：
UserDao.java
~~~
package com.bjpowernode.spring.dao;
public interface UserDao {
public void addUser(String userName,String password);
}
~~~
UserDao4MySqlImpl.java
~~~
package com.bjpowernode.spring.dao;
public class UserDao4MySqlImpl implements UserDao {
public void addUser(String userName, String password) {
// TODO Auto-generated method stub
System.out.println("UserDao4MySqlImpl.addUser()");
}
}
~~~
UserDao4OrcleImpl.java
~~~
package com.bjpowernode.spring.dao;
public class UserDao4OrcleImpl implements UserDao {
public void addUser(String userName, String password) {
// TODO Auto-generated method stub
System.out.println("UserDao4OrcleImpl.addUser()");
}
}
~~~
UserManager.java
~~~
package com.bjpowernode.spring.manager;
public interface UserManager {
public void addUser(String userName,String password);
}
~~~
UserManagerImpl.java
~~~
package com.bjpowernode.spring.manager;
import com.bjpowernode.spring.dao.UserDao;
public class UserManagerImpl implements UserManager{
private UserDao userDao;
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
// public UserManagerImpl(UserDao userDao) {
//
// this.userDao = userDao;
// }
public void addUser(String userName, String password) {
// TODO Auto-generated method stub
// //由我们的应用程序负责服务定位
// UserDao userDao=new UserDao4MySqlImpl();
userDao.addUser(userName, password);
}
}
~~~
Client.java
~~~
package com.bjpowernode.spring.client;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.bjpowernode.spring.dao.UserDao4MySqlImpl;
import com.bjpowernode.spring.manager.UserManager;
import com.bjpowernode.spring.manager.UserManagerImpl;
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
BeanFactory factory=new ClassPathXmlApplicationContext("applicationContext.xml");
UserManager userManager=(UserManager) factory.getBean("userManager");
userManager.addUser("张三", "123");
// // TODO Auto-generated method stub
// UserManager userManager=new UserManagerImpl(new UserDao4MySqlImpl());
// userManager.addUser("张三", "1231");
}
}
~~~
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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd
http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd">
<bean id="userDao4MySql" class="com.bjpowernode.spring.dao.UserDao4MySqlImpl"/>
<bean id="userDao4Orcle" class="com.bjpowernode.spring.dao.UserDao4OrcleImpl"/>
<bean id="userManager" class="com.bjpowernode.spring.manager.UserManagerImpl">
<!-- <constructor-arg ref="userDao4MySql" /> -->
<property name="userDao" ref="userDao4MySql"/>
</bean>
</beans>
~~~
运行结果：
## 三、比较
与原来用工厂写的区别就在于UserManagerImpl.java和Client.java这两个类的写法不一样原来这两个类这样写
UserManagerImpl.java
~~~
package com.bjpowernode.spring.manager;
import com.bjpowernode.spring.dao.UserDao;
import com.bjpowernode.spring.dao.UserDao4MySqlImpl;
public class UserManagerImpl implements UserManager{
public void addUser(String userName, String password) {
// TODO Auto-generated method stub
//由我们的应用程序负责服务定位
UserDao userDao=new UserDao4MySqlImpl();
userDao.addUser(userName, password);
}
}
~~~
Client.java
~~~
package com.bjpowernode.spring.client;
import com.bjpowernode.spring.manager.UserManager;
import com.bjpowernode.spring.manager.UserManagerImpl;
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
UserManager userManager=new UserManagerImpl();
userManager.addUser("张三", "1231");
}
}
~~~
## 四、总结
Spring给我们带来了很大的便利这样让我们开发的时候对象与对象之间进行了解耦。让我们维护起来更加方便，当需求修改的时候我们只要修改一下配置文件，添加对象就可以了不用修改写好的代码。
菜鸟学习Spring——初识Spring
最后更新于：2022-04-01 09:33:57
## 一、概念。
Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。
◆目的：解决企业应用开发的复杂性◆功能：使用基本的JavaBean代替EJB，并提供了更多的企业应用功能◆范围：任何Java应用简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面（AOP）的容器框架。◆轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。◆控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。◆面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。◆容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。◆框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。◆MVC——Spring的作用是整合，但不仅仅限于整合，Spring 框架可以被看做是一个企业解决方案级别的框架。客户端发送请求，服务器控制器（由DispatcherServlet实现的)完成请求的转发，控制器调用一个用于映射的类HandlerMapping，该类用于将请求映射到对应的处理器来处理请求。HandlerMapping 将请求映射到对应的处理器Controller（相当于Action）在Spring 当中如果写一些处理器组件，一般实现Controller 接口，在Controller 中就可以调用一些Service 或DAO 来进行数据操作 ModelAndView 用于存放从DAO 中取出的数据，还可以存放响应视图的一些数据。 如果想将处理结果返回给用户，那么在Spring 框架中还提供一个视图组件ViewResolver，该组件根据Controller 返回的标示，找到对应的视图，将响应response 返回给用户。所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。
## 二、Spring核心
Spring一共有7个模块组成如下图：
这几个模块的功能包括：
Core包是框架的基本组成部分，它提供依赖注射及Bean容器的管理功能。它的BeanFactory消除了应用对Singleton和Factory的依赖。
AOP包提供了与AOP联盟兼容的AOP实现，允许定义方法、拦截器、切入点等。通过AOP，在应用程序逻辑上实现了关注点的横切分离。
Context包构建于Bean包之上，它提供了一种框架式的Bean访问方式，类似JNDI机制，Context包提供了Bean包之上的功能扩展。
DAO包提供了JDBC抽象，消除了冗长的JDBC编码，并转译了数据库厂商特有的错误代码。该包也提供了编程式和声明式的事务管理。
ORM包为流行的关系/对象映射方案提供集成的借口。
WebMVC包提供了面向Web应用的MVC实现Spring的MVC和Ioc容器的整合提供了较大的灵活性Web包提供了面向Web的综合特性，如使用Servlet监听器的Context初始化、文件上传等功能。此外它也用于同其他Web框架的集成。
## 三、综述。
Spring为我们访问底层的J2EE容器服务更为简单，有了Spring我们的开发效率将大大提高。
菜鸟学习Hibernate——缓存
最后更新于：2022-04-01 09:33:55
Hibernate的缓存分为三种：一级缓存、二级缓存、查询缓存。下面我就为大家介绍一下。
## 一、概念。
一级缓存：第一级存放于session中称为一级缓存。Session 级别的缓存，它同session邦定。它的生命周期和session相同。Session消毁，它也同时消毁；管理一级缓存，一级缓存无法取消，用两个方法管理，clear(),evict()。两个session 不能共享一级缓存，因它会伴随session的生命周期的创建和消毁；Session缓存是实体级别的缓存，就是只有在查询对象级别的时候才使用，如果使用HQL和SQL是查询属性级别的，是不使用一级缓存的！
当程序调用save(),update(),saveorupdate()等方法 及调用查询接口list,filter,iterate时，如session缓存中还不存在相应的对象，Hibernate会把该对象加入到一级缓存中，当Session关闭的时候该Session所管理的一级缓存也会立即被清除Hibernate的一级缓存是Session所内置的，不能被卸载，也不能进行任何配置。
一级缓存的物理介质为内存，由于内存容量有限，必须通过恰当的检索策略和检索方式来限制加载对象的数目。
二级缓存：第二级别的缓存是SessionFactory级别的缓存，它是属于进程范围或群集范围的缓存。这一级别的缓存可以进行配置和更改，并且可以动态加载和卸载。第二级缓存的物理介质可以是内存和硬盘，因此第二级缓存可以存放大量的数据，数据过期策略的maxElementsInMemory属性值可以控制内存中的对象数目。管理第二级缓存主要包括两个方面：选择需要使用第二级缓存的持久类，设置合适的并发访问策略：选择缓存适配器，设置合适的数据过期策略。
查询缓存：hibernate的查询缓存是主要是针对普通属性结果集的缓存， 而对于实体对象的结果集只缓存id。在一级缓存,二级缓存和查询缓存都打开的情况下作查询操作时这样的：查询普通属性，会先到查询缓存中取，如果没有，则查询数据库；查询实体，会先到查询缓存中取id，如果有，则根据id到缓存(一级/二级)中取实体，如果缓存中取不到实体，再查询数据库。和一级/二级缓存不同，查询缓存的生命周期 ，是不确定的，当前关联的表发生改变时，查询缓存的生命周期结束。
## 二、对比。
## 三、总结。
缓存对于我们来说很重要可以提高系统的性能，把一些经常用到的数据，大的数据存到缓存中这样查询起来比直接查询数据库更加高效。对于大数据量的今天缓存的应用为我们提高效率提供了可能。
PS：这个是一个关于缓存机制的博客：[http://www.blogjava.net/tbwshc/articles/380013.html](http://www.blogjava.net/tbwshc/articles/380013.html)
菜鸟学习Hibernate——多对多关系映射
最后更新于：2022-04-01 09:33:52
Hibernate中的关系映射，最常见的关系映射之一就是多对多关系映射例如用户与角色的关系，一个用户对应多个角色，一个角色对应多个用户。如图：
Hibernate中如何来映射这两个的关系呢？
下面就为大家讲解一下：
1、创建实体类User和实体类Role
User.java
~~~
package com.bjpowernode.hibernate;
import java.util.Set;
public class User {
private int id;
private String name;
private Set roles;
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 Set getRoles() {
return roles;
}
public void setRoles(Set roles) {
this.roles = roles;
}
}
~~~
Role.java
~~~
package com.bjpowernode.hibernate;
public class Role {
private int id;
private String name;
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;
}
~~~
2、创建映射文件User.hbm.xml和Role.hbm.xml
User.hbm.xml
~~~
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.bjpowernode.hibernate.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="roles" table="t_user_role">
<key column="user_id"/>
<many-to-many class="com.bjpowernode.hibernate.Role" column="role_id" />
</set>
</class>
</hibernate-mapping>
~~~
Role.hbm.xml
~~~
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.bjpowernode.hibernate.Role" table="t_role">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
</class>
</hibernate-mapping>
~~~
3、效果图
菜鸟学习Hibernate——一对多关系映射
最后更新于：2022-04-01 09:33:50
Hibernate中的关系映射，最常见的关系映射之一就是一对多关系映射例如学生与班级的关系，一个班级对应多个学生。如图：
Hibernate中如何来映射这两个的关系呢？
下面就为大家讲解一下：
1、创建实体类Classes和实体类Student
Classes.java
~~~
package com.bjpowernode.hibernate;
import java.util.Set;
public class Classes {
private int id;
private String name;
private Set students;
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 Set getStudents() {
return students;
}
public void setStudents(Set students) {
this.students = students;
}
}
~~~
Student.java
~~~
package com.bjpowernode.hibernate;
public class Student {
private int id;
private String name;
private Classes classes;
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 Classes getClasses() {
return classes;
}
public void setClasses(Classes classes) {
this.classes = classes;
}
}
~~~
2、创建映射文件Classes.hbm.xml和Student.hbm.xml
Classes.hbm.xml
~~~
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.bjpowernode.hibernate.Classes" table="t_classes">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<set name="students" inverse="true">
<!--
<key column="classesid" not-null="true"/>
-->
<key column="classesid"/>
<one-to-many class="com.bjpowernode.hibernate.Student"/>
</set>
</class>
</hibernate-mapping>
~~~
Student.hbm.xml
~~~
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.bjpowernode.hibernate.Student" table="t_student">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<many-to-one name="classes" column="classesid"/>
</class>
</hibernate-mapping>
~~~
3、效果图
PS：我上面举例的是一对多双向关联的例子。有双向关联当然就有单向关联。下面举个例子来说明他们的区别
如果Student添加了一条记录当中的classesid在Classes中没有这个id，双向关联的话则先添加学生这条记录然后再班级那里添加这个班级，然后再更新学生的classesid。单向关联的话先添加班级，然后再添加学生。
菜鸟学习Hibernate——简单的增、删、改、查操作
最后更新于：2022-04-01 09:33:48
上篇博客利用Hibernate搭建起一个简单的例子，把数据库的映射显示了出来在上一篇的博客基础上这篇博客讲述如何利用Hinbernate框架实现简单的数据库操作。
1、加入junit.jar
2、新建一个工具类HibernateUtils.Java把一些对session的公共操作封装起来
~~~
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtils {
/*
*读取Hibernate.cfg.xml文件
*/
private static SessionFactory factory;
static {
try {
//读取hibernate.cfg.xml文件
Configuration cfg = new Configuration().configure();
//建立SessionFactory
factory = cfg.buildSessionFactory();
}catch(Exception e) {
e.printStackTrace();
}
}
/*
*打开Session
*/
public static Session getSession() {
return factory.openSession();
}
/*
*关闭Session
*/
public static void closeSession(Session session) {
if (session != null) {
if (session.isOpen()) {
session.close();
}
}
}
public static SessionFactory getSessionFactory() {
return factory;
}
}
~~~
3、新建一个test类继承TestCase（Junit包里面的）然后下面就利用test类对User对象的增、删、改、查。
~~~
import java.util.Date;
import org.hibernate.Session;
import com.bjpowernode.hibernate.HibernateUtils;
import com.bjpowernode.hibernate.User;
import junit.framework.TestCase;
public class test extends TestCase {
/*
* 增加User
*/
public void testSave() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
User user = new User();
user.setName("李四");
user.setPassword("123");
user.setCreateTime(new Date());
user.setExpireTime(new Date());
session.save(user);
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
/**
* 删除
*/
public void testDel(){
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
User user=(User)session.load(User.class, "4028989545a244640145a24466300001");
session.delete(user);
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
/**
* 修改
*/
public void testUpdate(){
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
User user=(User)session.load(User.class, "4028989545a243ca0145a243cbf80001");
user.setName("王五");
session.update(user);
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
/**
* 查询
*/
public void testLoad(){
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
User user=(User)session.load(User.class, "4028989545a243ca0145a243cbf80001");
System.out.println(user.getName());
System.out.println(user.getId());
System.out.println(user.getPassword());
System.out.println(user.getClass());
System.out.println(user.getCreateTime());
System.out.println(user.getExpireTime());
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
}
~~~
4、效果图
增
删
改
查
总结：
利用Hibernate简单的增、删、改、查操作的应用是一个很基础的应用刚学Hibernate就应该先从简单的学起。
菜鸟学习Hibernate——简单的一个例子
最后更新于：2022-04-01 09:33:46
## 一、Hibernate开发。
上篇博客已经为大家介绍了持久层框架的发展流程，持久层框架的种类。
为了能够使用Hibernate快速上手，我们先讲解一个简单的Hibernate应用实例hibernate_first。
## 二、开发流程。
1.首先在MyEclipce中新建一个hibernate_first的项目，然后新建后的项目目录为：
2.[配置Hibernate环境。](http://blog.csdn.net/gwblue/article/details/22691335)
3.编写持久化类User.java
~~~
package com.bjpowernode.hibernate;
import java.util.Date;
public class User {
private String id;
private String name;
private String password;
private Date createTime;
private Date expireTime;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public Date getCreateTime() {
return createTime;
}
public void setCreateTime(Date createTime) {
this.createTime = createTime;
}
public Date getExpireTime() {
return expireTime;
}
public void setExpireTime(Date expireTime) {
this.expireTime = expireTime;
}
}
~~~
4.编写生成映射文件User.hbm.xml。
~~~
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.bjpowernode.hibernate.User">
<id name="id">
<generator class="uuid"/>
</id>
<property name="name"/>
<property name="password"/>
<property name="createTime"/>
<property name="expireTime"/>
</class>
</hibernate-mapping>
~~~
5.编写hibernate.cfg.xml文件。
~~~
<!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="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_frist</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.show_sql">true</property>
<property name="hibernate.format_sql">true</property>
<mapping resource="com/bjpowernode/hibernate/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
~~~
6.生成表的类ExportDB.java。
~~~
package com.bjpowernode.hibernate;
import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
/**
* 将hbm生成ddl
* @author Administrator
*
*/
public class ExportDB {
public static void main(String[] args) {
//默认读取hibernate.cfg.xml文件
Configuration cfg = new Configuration().configure();
SchemaExport export = new SchemaExport(cfg);
export.create(true, true);
}
}
~~~
7.以上六个步骤已经把表建起来了下面我们就保存个数据，新建一个Client.java类来存入一个数据。代码如下：
~~~
package com.bjpowernode.hibernate;
import java.util.Date;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class Client {
public static void main(String[] args) {
//读取hibernate.cfg.xml文件
Configuration cfg = new Configuration().configure();
//建立SessionFactory
SessionFactory factory = cfg.buildSessionFactory();
//取得session
Session session = null;
try {
session = factory.openSession();
//开启事务
session.beginTransaction();
User user = new User();
user.setName("张三");
user.setPassword("123");
user.setCreateTime(new Date());
user.setExpireTime(new Date());
//保存User对象
session.save(user);
//提交事务
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
//回滚事务
session.getTransaction().rollback();
}finally {
if (session != null) {
if (session.isOpen()) {
//关闭session
session.close();
}
}
}
}
}
~~~
## 三、总结。
一个简单的Hibernate例子就出来了在Hibernate初学时利用这个例子可以让我们更好的入门。
菜鸟学习Hibernate——持久层框架
最后更新于：2022-04-01 09:33:43
## 一、Java操作数据库的阶段。
Java对数据库进行操作经历了三个阶段。
1.1操作JDBC阶段
这个阶段就是利用JDBC类来操作数据库。这个阶段出现了两个问题：
代码过度重复：在每一次数据库操作的是后都要编写相似的代码。实际上每一次这些代码有的是只是SQL语句改变但是还是得写一遍。让我想起第一次用.NET做机房收费系统的时候就写查询的时候除了SQL语句不一样以外其他都一样。
不能突出业务：整个代码都是数据库处理的代码，体现不出业务操作逻辑。
1.2封装JDBC阶段
这个阶段其实就是像.NET一样写SQLHelper把一些操作封装成方法，用到了调用就行了。封装一些常用的操作比如：加载数据库驱动，执行更新SQL执行，查询SQL，关闭对象，关闭数据库连接等。
1.3ORM阶段
ORM（ObjectRelational Mapping）是对象关系映射。这个是对JDBC进行了封装之后，能够方便地实现数据库的操作。ORM它是一种为了解决面向对象与关系数据库存在的互补匹配的现象的技术。ORM通过使用描述对象和数据库之间映射的元数据，将Java程序中的对象自动持久化到关系数据库中。ORM的实现产品有Apache OJB，Cayenne，Jaxor，iBatis，jRelationalFramework和现在学的Hibernate等。
## 二、持久层框架
iBatis：
使用ibatis提供的ORM机制，对业务逻辑实现人员而言，面对的是纯粹的Java对象， 这一层与通过Hibernate 实现ORM而言基本一致，而对于具体的数据操作，Hibernate 会自动生成SQL 语句，而ibatis 则要求开发者编写具体的SQL 语句。相对Hibernate等“全自动”ORM机制而言，ibatis 以SQL开发的工作量和数据库移植性上的让步，为系统 设计提供了更大的自由空间。作为“全自动”ORM实现的一种有益补充，ibatis 的出现显 得别具意义。
Hibernate：这是目前最流行的持久层框架，它是对JDBC的轻量级的对象封装，可以用在任何JDBC可以使用的场合。
## 三、总结
持久层框架能为我们提供更方便快捷的开发。一个成熟的持久层框架给我们带来了一下好处：
·减少了乏味的代码
持久层框架封装了数据库持久层大多数技术细节，让我们可以从JDBC的编码中解脱出来，将我们的精力更多的放到有价值的工作中去。
·更加面向对象设计
ORM为系统设计提供了更加自然的实现方式。我们可以通过ORM将系统中的对象自动映射到各个数据表中，从而编码中只需关心对象的相关属性无需在纠缠于JDBCResultSet中的字段数据
·更好的性能
很多持久层框架提供了优秀的性能优化机制，这些优化的综合使用大大提升了系统性能。
·更好的移植性
基于Java的跨平台特性，我们的系统可以在不同操作系统之间切换。但由于数据库之间的差异，系统在数据库平台之间的迁移却遇到了阻力。上面提及的这些成熟持久层框架，由于设计上的良好隔离，从而提供了对不同数据库的良好支持，我们只需简单地修改其配置参数，即可实现底层数据库的切换。
菜鸟学习Hibernate——配置Hibernate环境
最后更新于：2022-04-01 09:33:41
## 一、概念。
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。既然学习Hibernate那么第一步就要学会如何配置hibernate环境。只有配置好环境才能进行hibernate项目的编写。下面我就为大家介绍如何配置Hibernate。
## 二、配置Hibernate步骤。
2.1添加jar包。
把hibernate-3.2.0.ga\hibernate-3.2\lib下的所有jar包加上。
2.2编写hibernate.cfg.xml
~~~
<!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="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/hibernate_frist</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">root</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.show_sql">true</property>
<property name="hibernate.format_sql">true</property>
<mapping resource="com/bjpowernode/hibernate/User.hbm.xml"/>
</session-factory>
</hibernate-configuration>
~~~
就这么简单的两步就可以把hibernate环境搭建好。