Spring（二）

测试：
public class Test {
public static void main(String[] args) {
ApplicationContext ctx = null;
// 表示找到配置文件
ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
// 从配置文件之中取得Bean的实例
Person per = (Person) ctx.getBean("per9");
System.out.println(per);
Iterator iter = per.getBooks().entrySet().iterator();
while (iter.hasNext()) {
Map.Entry me = (Map.Entry) iter.next();
Book b = (Book) me.getValue();
System.out.println("\t|- " + me.getKey() + " --> " + b.getTitle());
}
}
}
在以后的开发中Properties注入是最常见的一种，属性。
import java.util.Properties;
public class Person {
private Properties mypro ;
public Properties getMypro() {
return mypro;
}
public void setMypro(Properties mypro) {
this.mypro = mypro;
}
}
之后在配置文件中建立关系
<bean id="per" class="org.lxh.ioc.demo10.Person">
<property name="mypro">
<props>
<prop key="key1">value1</prop>
<prop key="key2">value2</prop>
<prop key="key3">value3</prop>
</props>
</property>
</bean>
准备好了三个所需要的属性值
public class Test {
public static void main(String[] args) {
ApplicationContext ctx = null;
// 表示找到配置文件
ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
// 从配置文件之中取得Bean的实例
Person per = (Person) ctx.getBean("per");
System.out.println(per.getMypro());
}
}
3.3、AOP（了解）
AOP：面向方面的编程。
代理设计模式：
• 一个接口定义两个子类，其中一个子类包含另外一个子类。
• 代理完成比真实实现类更多的操作。
Subject.java：
package org.lxh.aop.demo01;
public interface Subject {
public void request() ;
}
真实主题实现类：RealSubject.java：
package org.lxh.aop.demo01;
public class RealSubject implements Subject {
public void request() {
System.out.println("真实的业务操作。。。");
}
}
代理主题操作类：ProxySubject.java：
package org.lxh.aop.demo01;
public class ProxySubject implements Subject {
private Subject sub = null ;
public ProxySubject(Subject sub){
this.sub = sub ;
}
public void before(){
System.out.println("操作开始的相关业务。");
}
public void request() {
this.before() ;
this.sub.request() ;
this.after() ;
}
public void after(){
System.out.println("将操作进行日志记录。");
}
}
测试类：
package org.lxh.aop.demo01;
public class Test {
public static void main(String[] args) {
Subject sub = new ProxySubject(new RealSubject()) ;
sub.request() ;
}
}
以上的程序是一个代理的基本操作。属于静态代理类的功能，但是如果要对多个接口进行代理，则无法做到，此时就要对程序进行扩充，使用动态代理操作。
动态代理操作中，一个类只需要实现InvocationHandler接口即可。
动态代理类Proxy.java：
package org.lxh.aop.demo02;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class Proxy implements InvocationHandler {
private Object sub;
public Object bind(Object obj) { // 绑定一个真实的对象操作
this.sub = obj;
return java.lang.reflect.Proxy.newProxyInstance(obj.getClass()
.getClassLoader(), obj.getClass().getInterfaces(), this);
}
public Object invoke(Object arg0, Method arg1, Object[] arg2)
throws Throwable {
// 调用接口中的方法
this.before();
Object obj = arg1.invoke(this.sub, arg2);
this.after();
return obj;
}
public void before() {
System.out.println("操作开始的相关业务。");
}
public void after() {
System.out.println("将操作进行日志记录。");
}
}
此时，通过程序进行测试。
package org.lxh.aop.demo02;
public class Test {
public static void main(String[] args) {
Subject sub = (Subject)new Proxy().bind(new RealSubject()) ;
sub.request() ;
}
}
以后只要想修改所有代理的相关业务操作，只需要修改动态代理类即可。
此时，可以直接使用Spring中的AOP功能，在配置文件中对程序进行功能的增加，以后只要修改配置文件，就可以完成程序横切面上的操作。
如果要想实现这样的AOP功能，在Spring中提供了若干个Advices接口，直接使用此接口实现类，就可以完成程序的之前操作、之后操作的代码。
例如：将之前的代码
使用MethodBeforeAdvice接口定义一个子类，就表示之前的操作代码类。
Before.java：
package org.lxh.aop.demo03;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
public class Before implements MethodBeforeAdvice {
public void before(Method arg0, Object[] arg1, Object arg2)
throws Throwable {
System.out.println("*** 代理之前的操作！") ;
}
}
也就是把之前在代理类之中编写的before()方法，单独提取到一个类之中了，以后直接配置此类的实例就可以完成代理操作之前的工作。
在AOP中就必须在applicationContext.xml文件之中进行若干个配置才可以完成这种AOP开发。
applicationContext.xml：
<bean id="before"  定义真实主题操作之前的功能
class="org.lxh.aop.demo03.Before"></bean>
<bean id="subject"  定义接口
class="org.lxh.aop.demo03.Subject"
abstract="true">
</bean>
<bean id="realsubject"  定义接口实现类
class="org.lxh.aop.demo03.RealSubject"
parent="subject">
</bean>
<bean id="proxy"
class="org.springframework.aop.framework.ProxyFactoryBean">  spring中已经提供了一个代理的操作类，只需要设置好若干属性即可
<property name="proxyInterfaces">  被代理的接口
<value>org.lxh.aop.demo03.Subject</value>
</property>
<property name="target">  代理中所包含的真实实现类
<ref bean="realsubject" />
</property>
<property name="interceptorNames">
<list>
<value>before</value>  定义before，因为实现MethodBeforeAdvices接口，所以会自动设置成在主题调用之前操作此代码。
</list>
</property>
</bean>
测试：
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args) {
ApplicationContext ctx = null ;
ctx = new ClassPathXmlApplicationContext("applicationContext.xml") ;
Subject sub = (Subject)ctx.getBean("proxy") ;
sub.request() ;
}
}
程序运行之后，代理之前的操作已经调用了。
同样，也可以在方法执行完毕之后进行相关的收尾工作：AfterReturningAdvice接口。
After.java：
import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;
public class After implements AfterReturningAdvice {
public void afterReturning(Object arg0, Method arg1, Object[] arg2,
Object arg3) throws Throwable {
System.out.println("*** 收尾工作。。。") ;
}
}
此类就是取代了after()方法的操作。
直接在applicationContext.xml中配置收尾的工作。
applicationContext.xml：
<bean id="before" class="org.lxh.aop.demo03.Before"></bean>
<bean id="after" class="org.lxh.aop.demo03.After"></bean>
<bean id="subject" class="org.lxh.aop.demo03.Subject"
abstract="true">
</bean>
<bean id="realsubject" class="org.lxh.aop.demo03.RealSubject"
parent="subject">
</bean>
<bean id="proxy"
class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="proxyInterfaces">
<value>org.lxh.aop.demo03.Subject</value>
</property>
<property name="target">
<ref bean="realsubject" />
</property>
<property name="interceptorNames">
<list>
<value>before</value>
<value>after</value>
</list>
</property>
</bean>
所谓的AOP就是可以对程序进行灵活的配置，把与具体业务无关的操作都统一形成一个个的操作类，在配置文件之中进行整合。
3.4、SSH整合（绝对重点）
SSH：Struts + Spring + Hibernate。使用此种方式，程序中不再需要工厂，不再需要手工管理数据库连接，所有的属性配置都在Spring中完成。但是因为程序发展的历史问题，SSH整合是最麻烦的。
在整个操作中如果那个部分出错了，则全部的配置作废。
三个框架每个框家都有自己的配置文件：
• Struts：struts-config.xml
• Hibernate：hiberante.cfg.xml、*.hbm.xml
• Spring：applicationContext.xml
整合之后，Hibernate的配置文件将不再需要，所有的配置信息直接写在applicationContext.xml中即可。
但是添加框架支持的顺序：Spring  Hibernate  Struts。
整个一个程序，以简单的登陆程序为准，
3.4.1、准备工作
新建立一个项目：SSHDemo。
在MyEclipse中配置数据库的连接。
建立如下的数据库创建脚本：
USE demo ;
DROP TABLE user ;
CREATE TABLE user(
id VARCHAR(50) PRIMARY KEY NOT NULL ,
name VARCHAR(50) NOT NULL ,
password VARCHAR(32)
) ;
INSERT INTO user(id,name,password) VALUES ('admin','管理员','admin') ;
3.4.2、Spring + Hibernate
一定要记住：先加入Spring，之后再加入Hibernate，而且本身在加入之前必须保证已经建立好了一个数据库连接。

添加包的时候，一定要选择以下几个：
• Spring核心包
• Hiberante 3的支持开发包
• AOP包
• WEB支持的包，如果不加此包，则以后无法在web上使用Spring。

配置文件还是applicationContext.xml。
在Spring中所有的容器的信息都是通过log4j完成，需要建立一个log4j.properties的文件，用于打印容器启动问题的各种信息。
log4j.properties：
log4j.rootLogger=INFO, stdout, logfile
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.logfile=org.apache.log4j.RollingFileAppender
log4j.appender.logfile.File=d:/ssh.log
log4j.appender.logfile.MaxFileSize=512KB
# Keep three backup files.
log4j.appender.logfile.MaxBackupIndex=3
# Pattern to output: date priority [category] - message
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n
添加完spring之后加上Hibernate支持。
添加的时候将所有的包全部选中，之后的把所有的包加入到WEB-INF/lib目录之中。



此项目已经存在了Spring，所以此时询问，是否把Hibernate直接加入spring进行管理，选择加入管理，这样就不会再建立hibernate.cfg.xml文件了。

此处，表示在applicationContext.xml中配置一个sessionFactory，sessionFactory在Hibernate中表示所有的数据库连接，可以从中取得一个Session。

Spring + Hibernate中肯定需要操作数据库，此处表示使用的数据库配置，beanid表示的是Spring配置文件中的一个bean节点配置。

因为Hibernate中添加的包，可能与Spring中的包重复，所以此处询问，是否需要把旧的包进行替换。
此时就已经自动在applicationContext.xml中加入了Hibernate的若干配置。
applicationContext.xml说明：
1、 数据库连接配置
<bean id="dataSource"  表示文件中的一个实例
class="org.apache.commons.dbcp.BasicDataSource">  使用了dbcp的JDBC操作包，使用此类进行数据库连接的操作管理。此类本身由Spring提供完成。
<property name="driverClassName"
value="org.gjt.mm.mysql.Driver">  数据库的驱动程序
</property>
<property name="url"  连接地址
value="jdbc:mysql://localhost:3306/demo"></property>
<property name="username" value="root"></property>  用户名
<property name="password" value="mysqladmin"></property>  密码
</bean>
以后如果要把JDBC连接变为JNDI连接直接更换此处即可，其他的所有代码都不用改变。
2、 配置Hiberante的连接
<bean id="sessionFactory"  配置的是一个连接工厂
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">  表示要使用的数据库连接
<ref bean="dataSource"></ref>  连接使用dataSource实例
</property>
<property name="hibernateProperties">  Hibernate中的若干属性
<props>
<prop key="hibernate.dialect">
org.hibernate.dialect.MySQLDialect  数据库的使用方言
</prop>
</props>
</property>
</bean>
在整个Spring中提供了一个Hibernate的操作模板，通过此模板可以帮用户自动处理何时打开数据库、何时关闭数据库。
3、 配置HibernateTemplate
<bean id="hibernateTemplate"
class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory">
<ref bean="sessionFactory"></ref>
</property>
</bean>
此处表示定义了一个操作的模板，所以在以后的程序代码中，如果要想使用此模板，必须让DAO的实现类继承了HibernateDaoSupport类。
使用之前的数据库创建脚本完成一个登陆功能。
通过表创建完POJO和hbm.xml文件之后，会在applicationContext.xml中增加以下的内容：
<property name="mappingResources">
<list>
<value>org/lxh/ssh/vo/User.hbm.xml</value>
</list>
</property>
表示的是所有的资源文件。
定义IUserDAO接口，同时声明一个登陆的操作：
package org.lxh.ssh.dao;
import org.lxh.ssh.vo.User;
public interface IUserDAO {
public boolean findLogin(User user) throws Exception ;
}
此类与之前一样，但是在建立实现类的时候就不一样，必须为实现类中增加Spring的Hibernate支持。
package org.lxh.ssh.dao.impl;
import java.sql.SQLException;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.lxh.ssh.dao.IUserDAO;
import org.lxh.ssh.vo.User;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
public class IUserDAOImpl extends HibernateDaoSupport implements IUserDAO {
public boolean findLogin(final User user) throws Exception {
boolean flag = false;
try {
flag = (Boolean) super.getHibernateTemplate().execute(
new HibernateCallback() {
public Object doInHibernate(Session session)
throws HibernateException, SQLException {
boolean flag = false;
String hql = "FROM User u WHERE u.id=? AND u.password=?";
Query q = session.createQuery(hql);
q.setString(0, user.getId());
q.setString(1, user.getPassword());
User u = (User) q.uniqueResult();
if (u != null) {
flag = true;
user.setName(u.getName());
}
return flag;
}
});
} catch (Exception e) {
throw e;
}
return flag;
}
}
之后修改applicationContext.xml文件，加入接口和实现类。
applicationContext.xml：
<bean id="iuserdao" class="org.lxh.ssh.dao.IUserDAO"
abstract="true">
</bean>
<bean id="iuserdaoimpl" class="org.lxh.ssh.dao.impl.IUserDAOImpl"
parent="iuserdao">
<property name="hibernateTemplate">
<ref bean="hibernateTemplate"></ref>
</property>
</bean>
此两种配置完成之后，实现类和接口就要统一的接受Spring的管理了，所有的数据库的打开与关闭操作都与程序本身无关，完全由Spring处理。
测试：
import org.lxh.ssh.dao.IUserDAO;
import org.lxh.ssh.vo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
public static void main(String[] args) throws Exception {
ApplicationContext ctx = new ClassPathXmlApplicationContext(
"applicationContext.xml");
IUserDAO dao = (IUserDAO) ctx.getBean("iuserdaoimpl");
User user = new User();
user.setId("admin");
user.setPassword("admin");
System.out.println(dao.findLogin(user));
System.out.println(user.getName());
}
}
但此时在运行时出现了以下的错误：
Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'dataSource' defined in class path resource [applicationContext.xml]: Instantiation of bean failed; nested exception is java.lang.NoClassDefFoundError: org/apache/commons/pool/impl/GenericObjectPool
Caused by: java.lang.NoClassDefFoundError: org/apache/commons/pool/impl/GenericObjectPool
以上的错误提示是缺少必要的包。

之前存在一个替换包的过程，所以有可能有些包就无法加进来，此时必须手工加入所要的包。
添加完成之后，如果此包还没有的话，则可以从Spring的开发包中拷贝出来，放在lib之中。
之前在使用Hibernate的时候，可以直接在hibernate.cfg.xml文件中进行显示SQL语句的配置，实际上现在就可以直接把此属性加在applicationContext.xml文件之中。
<prop key="hibernate.show_sql">true</prop>
以后再操作数据库的时候就会自动显示所执行的SQL语句了。
3.4.3、Struts + Spring + Hibernate
完成了后台代码之后，下面就需要完成前台的操作，因为Spring本身是一个容器，所以需要在web.xml中注册此容器。
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/classes/applicationContext.xml
</param-value>
</context-param>
找到applicationContext.xml中的配置文件，此文件将在容器启动的时候加载，同时启动Spring容器。
如果要想正确的启动容器，还需要增加一个监听：
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
此两个配置为固定的，表示允许WEB中使用Spring。
为项目添加Struts支持。
因为Sturts出现较早，所以对于配置来说比较麻烦，跟验证框架一样，Spring在Struts中是以插件的形式出现的，需要在struts-config.xml中进行配置。
<plug-in
className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation"
value="/WEB-INF/classes/applicationContext.xml" />
</plug-in>
就表示Struts中集成了Spring管理了。
建立Struts的AcionForm、Action。
UserAction.java：
package og.lxh.ssh.struts.action;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import og.lxh.ssh.struts.form.UserForm;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.DispatchAction;
import org.lxh.ssh.dao.IUserDAO;
import org.lxh.ssh.vo.User;
public class UserAction extends DispatchAction {
private IUserDAO iuserdao = null;
public ActionForward execute(ActionMapping mapping, ActionForm form,
HttpServletRequest request, HttpServletResponse response) {
UserForm userForm = (UserForm) form;
User user = new User();
user.setId(userForm.getId());
user.setPassword(userForm.getPassword());
try {
if (this.iuserdao.findLogin(user)) {
request.setAttribute("flag", true);
} else {
request.setAttribute("flag", false);
}
} catch (Exception e) {
e.printStackTrace();
}
return mapping.findForward("logindo");
}
// 此时的代码，会通过spring进行注入
public void setIuserdao(IUserDAO iuserdao) {
this.iuserdao = iuserdao;
}
}
以上是Struts中的代码。与之前相比把DAO作为一个类的属性存在了，不再像之前那样通过工厂取得，所有的DAO实例现在都是通过Spring注入进来的。
此时，应该把所有的Struts的处理请求先统一提交给Spring，因为Spring中要把DAO实例注入进来，所以在操作的时候要在struts-config.xml文件中加入以下的配置：
<controller
processorClass="org.springframework.web.struts.DelegatingRequestProcessor">
</controller>
加入以上的配置就表示所有的请求先交给Spring进行处理。
此时，就可以把完整的struts-config.xml文件整理出来：
<struts-config>
<data-sources />
<form-beans>
<form-bean name="userForm"
type="og.lxh.ssh.struts.form.UserForm" />
</form-beans>
<global-exceptions />
<global-forwards />
<action-mappings>
<action attribute="userForm" input="/form/user.jsp"
name="userForm" parameter="status" path="/user" scope="request"
type="og.lxh.ssh.struts.action.UserAction">
<forward name="logindo" path="/login.jsp"></forward>
</action>
</action-mappings>
<controller
processorClass="org.springframework.web.struts.DelegatingRequestProcessor">
</controller>
<message-resources
parameter="og.lxh.ssh.struts.ApplicationResources" />
<plug-in
className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation"
value="/WEB-INF/classes/applicationContext.xml" />
</plug-in>
</struts-config>
之后要在Spring中声明，Spring管理的是那个Action。修改applicationContext.xml文件。
applicationContext.xml：
<bean name="/user" class="og.lxh.ssh.struts.action.UserAction">
<property name="iuserdao">
<ref bean="iuserdaoimpl"></ref>
</property>
</bean>
此时，是把iuserdaoimpl的实例注入到Struts之中了。
建立JSP页面完成用户登陆操作
login.jsp：
<%@ page language="java" pageEncoding="GBK"%>
<%@ taglib uri="http://struts.apache.org/tags-bean" prefix="bean"%>
<%@ taglib uri="http://struts.apache.org/tags-html" prefix="html"%>
<%@ taglib uri="http://struts.apache.org/tags-logic" prefix="logic"%>
<%@ taglib uri="http://struts.apache.org/tags-tiles" prefix="tiles"%>
<html:html lang="true">
<head>
<title>login.jsp</title>
</head>
<body>
<logic:present name="flag" scope="request">
<logic:equal value="true" name="flag">
<h2>
登陆成功！
</h2>
</logic:equal>
<logic:equal value="false" name="flag">
<h2>
登陆失败！
</h2>
</logic:equal>
</logic:present>
<form action="user.do" method="post">
用户ID：
<input type="text" name="id">
<br>
密码：
<input type="password" name="password">
<br>
<input type="submit" value="登陆">
<input type="reset" value="重置">
</form>
</body>
</html:html>
将项目部署到tomcat服务器之中。
进行数据库连接池的配置：
<Context path="/ssh" docBase="E:\ld\SSHDemo\WebRoot"
debug="5" reloadable="true" crossContext="true">
<Resource name="jdbc/mysql"
auth="Container" type="javax.sql.DataSource"
maxActive="100" maxIdle="30" maxWait="10000"
username="root" password="mysqladmin"
driverClassName="org.gjt.mm.mysql.Driver"
url="jdbc:mysql://localhost:3306/mldnshop"/>
</Context>
<resource-ref>
<description>DB Connection</description>
<res-ref-name>jdbc/mysql</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
运行之后有可能出现以下的错误：
java.lang.NoSuchMethodError: org.objectweb.asm.ClassVisitor.visit(IILjava/lang/String;Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;)V
此错误是包的冲突造成的。删除掉冲突的包。把asm-2.2.3.jar包删除掉。
此时代码配置完成，SSH已经整合了，但是之前已经配置好了数据库连接池了，如果现在要在项目中使用数据库连接池，则必须更换一个数据库的操作模板。修改applicationContext.xml：
<bean id="dataSource"
class="org.springframework.jndi.JndiObjectFactoryBean">
<property name="jndiName">
<value>java:comp/env/jdbc/mysql</value>
</property>
</bean>
此时，程序中就可以使用JNDI的方式连接数据库了。
4、总结
1、 掌握Spring IOC的基本原理
2、 SSH项目整合