BlogJava-BeanSoft's Java Blog-随笔分类-Springhttp://www.blogjava.net/beansoft/category/23350.htmlMyEclipse 教程, Java EE 5, JSPWiki, Spring, Struts, Hibernate, JPA, SWT, Swing, AJAX, JavaScript, Netbeanszh-cnThu, 21 Feb 2008 06:12:54 GMTThu, 21 Feb 2008 06:12:54 GMT60IBM 中文网站的 Spring 系列等资料http://www.blogjava.net/beansoft/archive/2008/01/04/172725.htmlBeanSoftBeanSoftFri, 04 Jan 2008 05:33:00 GMThttp://www.blogjava.net/beansoft/archive/2008/01/04/172725.htmlhttp://www.blogjava.net/beansoft/comments/172725.htmlhttp://www.blogjava.net/beansoft/archive/2008/01/04/172725.html#Feedback0http://www.blogjava.net/beansoft/comments/commentRss/172725.htmlhttp://www.blogjava.net/beansoft/services/trackbacks/172725.html在电子书《MyEclipse 6 Java 开发中文教程》中列入了大量作者精心搜集的资料，今天把Spring部分的参考资料和大家分享：

翻译: MyEclipse Spring 入门教程(含官方视频和AOP例子) http://www.blogjava.net/beansoft/archive/2007/11/27/163416.html

使用 HibernateTemplate 实现分页查询 http://www.blogjava.net/beansoft/archive/2007/10/10/151702.html

转载: Eclipse插件之Spring IDE http://www.blogjava.net/beansoft/archive/2007/10/02/150127.html

IBM 开发网站的Spring系列（含代码）：

http://www-128.ibm.com/developerworks/cn/java/wa-spring1/ Spring 系列: Spring 框架简介――Spring AOP 和 IOC 容器入门

http://www-128.ibm.com/developerworks/cn/java/wa-spring2/ Spring 系列，第 2 部分: 当 Hibernate 遇上 Spring――Hibernate 事务天生适合 Spring AOP

http://www-128.ibm.com/developerworks/cn/java/wa-spring3/ Spring 系列，第 3 部分: 进入 Spring MVC――用 Spring MVC 轻松进行应用程序开发

http://www-128.ibm.com/developerworks/cn/java/wa-spring4/ Spring 系列，第 4 部分: Spring JMS 消息处理 1-2-3――Spring JMS 把企业消息处理变得轻而易举

来自满江红开源网站（http://wiki.redsaga.com/confluence/display/RSTEAM/Home）的中文文档：

《Spring 开发指南》 作者：Xiaxin (夏昕) PDF 格式169页, 1.02M 下载地址：http://www.xiaxin.net/Spring_Dev_Guide.rar

SpringFramework概述 翻译：DigitalSonic PDF 格式 24 页，322K 下载地址：

http://www.redsaga.com/opendoc/OpenDoc-IntroduceToSpringFramework.pdf

Spring 2.0 Reference（官方参考手册） 翻译：DigitalSonic 2006/10/22 完成 HTML版本地址：http://www.redsaga.com/opendoc/Seam2.0/html PDF版本(509页, 3.74M) 下载地址：http://download.gro.clinux.org/jaction/spring2.0-reference_final_zh_cn.pdf ,CHM版本(2.2M)下载地址：https://gro.clinux.org/frs/download.php/1828/spring2.0-reference_final_zh_cn.chm



BeanSoft 2008-01-04 13:33 发表评论
]]>Spring 1.2和2.0的简单AOP例子http://www.blogjava.net/beansoft/archive/2008/01/02/172266.htmlBeanSoftBeanSoftWed, 02 Jan 2008 09:33:00 GMThttp://www.blogjava.net/beansoft/archive/2008/01/02/172266.htmlhttp://www.blogjava.net/beansoft/comments/172266.htmlhttp://www.blogjava.net/beansoft/archive/2008/01/02/172266.html#Feedback5http://www.blogjava.net/beansoft/comments/commentRss/172266.htmlhttp://www.blogjava.net/beansoft/services/trackbacks/172266.html阅读全文

BeanSoft 2008-01-02 17:33 发表评论
]]>Spring 2.5 标注开发的简单例子http://www.blogjava.net/beansoft/archive/2007/11/30/164230.htmlBeanSoftBeanSoftFri, 30 Nov 2007 04:53:00 GMThttp://www.blogjava.net/beansoft/archive/2007/11/30/164230.htmlhttp://www.blogjava.net/beansoft/comments/164230.htmlhttp://www.blogjava.net/beansoft/archive/2007/11/30/164230.html#Feedback7http://www.blogjava.net/beansoft/comments/commentRss/164230.htmlhttp://www.blogjava.net/beansoft/services/trackbacks/164230.html 

研究了很久新出的 Spring 2.5, 总算大致明白了如何用标注定义 Bean, 但是如何定义和注入类型为 java.lang.String 的 bean 仍然未解决, 希望得到高人帮助.

总的来看 Java EE 5 的标注开发方式开来是得到了大家的认可了.

@Service 相当于定义 bean, 自动根据 bean 的类名生成一个首字母小写的 bean

@Autowired 则是自动注入依赖的类, 它会在类路径中找成员对应的类/接口的实现类, 如果找到多个, 需要用 @Qualifier("chineseMan") 来指定对应的 bean 的 ID.

一定程度上大大简化了代码的编写, 例如一对一的 bean 映射现在完全不需要写任何额外的 bean 定义了.

下面是代码的运行结果:

man.sayHello()=抽你丫的
SimpleMan said: Hi
org.example.EnglishMan@12bcd4b said: Fuck you!

 

代码:

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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
           http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
           http://www.springframework.org/schema/context
           http://www.springframework.org/schema/context/spring-context-2.5.xsd">
     <context:annotation-config/>
     <context:component-scan base-package="org.example"/>
     
</beans>

测试类:

import org.example.IMan;
import org.example.SimpleMan;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class SpringTest {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
        SimpleMan dao = (SimpleMan) ctx.getBean("simpleMan");
        System.out.println(dao.hello());
        IMan man = (IMan) ctx.getBean("usMan");
        System.out.println(man.sayHello());
    }
}

自动探测和注入bean的类:

package org.example;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class SimpleMan {
    // 自动注入名称为 Man 的 Bean
    @Autowired(required = false)
    @Qualifier("chineseMan")
    //@Qualifier("usMan")
    private IMan man;   

    /**
     * @return the man
     */
    public IMan getMan() {
        return man;
    }

    /**
     * @param man the man to set
     */
    public void setMan(IMan man) {
        this.man = man;
    }

    public String hello() {
        System.out.println("man.sayHello()=" + man.sayHello());
        return "SimpleMan said: Hi";
    }
}

 

一个接口和两个实现类:

package org.example;

/**
* 抽象的人接口.
* @author BeanSoft
* @version 1.0
*/
public interface IMan {
    /**
     * 打招呼的抽象定义.
     * @return 招呼的内容字符串
     */
    public String sayHello();
}

 

package org.example;

import org.springframework.stereotype.Service;

/**
* 中国人的实现.
* @author BeanSoft
*/
@Service
public class ChineseMan implements IMan {

    public String sayHello() {
        return "抽你丫的";
    }

}

 

package org.example;

import org.springframework.stereotype.Service;

/**
* @author BeanSoft
* 美国大兵
*/
@Service("usMan")
// 这里定义了一个 id 为 usMan 的 Bean, 标注里面的属性是 bean 的 id
public class EnglishMan implements IMan {

    public String sayHello() {
        return this + " said: Fuck you!";
    }

}

BeanSoft 2007-11-30 12:53 发表评论
]]>翻译: MyEclipse Spring 入门教程(含官方视频和AOP例子)http://www.blogjava.net/beansoft/archive/2007/11/27/163416.htmlBeanSoftBeanSoftTue, 27 Nov 2007 04:06:00 GMThttp://www.blogjava.net/beansoft/archive/2007/11/27/163416.htmlhttp://www.blogjava.net/beansoft/comments/163416.htmlhttp://www.blogjava.net/beansoft/archive/2007/11/27/163416.html#Feedback3http://www.blogjava.net/beansoft/comments/commentRss/163416.htmlhttp://www.blogjava.net/beansoft/services/trackbacks/163416.html这是 MyEclipse 帮助文档中的内容的翻译, 点击菜单 Help -> Contents 可以看到 MyEclipse 的全部英文帮助文档.

在线阅读(完整内容含 Flash 动画): http://beansoft.java-cn.org/myeclipse_doc_cn/springintroduction/

下载: http://cid-519b3f7aa2172030.skydrive.live.com/self.aspx/Public/MyEclipse中文文档/MyEclipse Spring 快速入门.zip 2.31MB 

友情提示: 下载微软网盘文件时关闭下载工具,  否则你将得到错误的文件, 双击 EXE 会出来 DOS 窗口. 正确操作是点击文件名后能看到显示下载链接和文件大小等信息.

MyEclipse Spring 入门教程
翻译: 刘长炯 BeanSoft@126.com
Blog: http://www.blogjava.net/beansoft/
日期: 2007-11-26
声明: 中文文字版权归 刘长炯 所有, 原文及相关的图片等资源的版权归原作者 Genuitec L.L.C 公司所有.

目录

  1. 简介
  2. 建议的听众
  3. 系统需求
  4. Spring 介绍
  5. 开始工作
  6. 可视化项目
  7. 理解和运行代码
  8. 修改项目
  9. 小结
  10. FAQ
  11. 资源
  12. 反馈

 

 

本人原创 MyEclipse 6 帮助文档中文版集中下载

http://cid-519b3f7aa2172030.skydrive.live.com/browse.aspx/Public/MyEclipse中文文档



BeanSoft 2007-11-27 12:06 发表评论
]]>击破谎言: Spring 2.5 并非&quot;完全&quot;支持基于标注的配置http://www.blogjava.net/beansoft/archive/2007/11/23/162700.htmlBeanSoftBeanSoftFri, 23 Nov 2007 10:14:00 GMThttp://www.blogjava.net/beansoft/archive/2007/11/23/162700.htmlhttp://www.blogjava.net/beansoft/comments/162700.htmlhttp://www.blogjava.net/beansoft/archive/2007/11/23/162700.html#Feedback3http://www.blogjava.net/beansoft/comments/commentRss/162700.htmlhttp://www.blogjava.net/beansoft/services/trackbacks/162700.html近日看到各大中文网站纷纷呛声说 Spring 2.5 发布, 典型消息如下:

 

来自 Springframework 官方的消息，Spring 2.5 正式发布了。

http://www.springframework.org/node/561

该版本的主要特征包括：
对Spring2.0的平滑升级 —— Spring2.5被设计成为对Spring2.0的平滑升级，现存的代码和配置文件不需要做任何更改。
更多XML命名空间配置 —— 新的命名空间包括和
完全支持Java 6和Java EE 5 —— Spring2.5支持Java 6和Java EE 5的所有新特性——同时也提供了对Java 1.4.2和J2EE1.3的支持。
完全支持基于注解的配置 —— 现在所有的配置都可以使用注解来实现，并且也支持 JSR250 注解。
基于注解的MVC controller —— Web Controller现在可以用如@RequestMapping这样的注解来创建，无需实现任何接口。
对AspectJ的支持 —— 在一些环境下，增加了对AspectJ的装载时编织支持，同时提供了一个新的bean切入点。
对OSGi的支持 —— Spring2.5框架的所有jar包都是兼容于OSGi的，以此来简化在OSGi环境下对其的使用。
测试框架的巨大改变 —— 现在新的基于注解的测试框架已经支持TestNG和JUnit4
性能的改良 —— Spring2.5各方面的性能指标都有了显著的改善。

冲着 完全支持基于注解的配置 这句话, 我兴冲冲的下载了 Spring 2.5 以及其文档, 企图体验一下 EJB 3 式的简单快速的基于标注的开发, 然而, 遗憾的是官方文档和消息的来源页面: http://www.springframework.org/node/561, 没有任何文字说到自己完全支持基于注解的配置. 我打开英文的 Reference, 仔细阅读其中关于标注的部分, 然而遗憾的发现只是部分实现了标注, 请参考 http://static.springframework.org/spring/docs/2.5.x/reference/beans.html#beans-annotation-config , 简单说就是实现了对 Autowired 和 Transaction, AOP 的标注支持, 而不是所有 bean 定义, 更不是说从此你可以不用写 Bean 配置的 XML 文件了. 下午仔细试了半天, 企图写出标注配置的例子来, 也没有成功实现不写 bean 定义 XML 文件就能初始化 Bean 并注入所有属性的功能(本来想做的例子是注入一个 message 的 String 属性), 去阅读下载的示例代码(example目录下的文件), 也没有这样的例子. 最后又发现了原来支持标注的版本在这里:

http://www.jroller.com/habuma/entry/guice_vs_spring_javaconfig_a

它的名字叫 Spring JavaConfig.

最后我们再来看看原始页面是如何介绍自己的标注的(http://www.springframework.org/node/561):

Spring 2.5 enhances Spring 2.0 with many exciting new features, including:
Full Java 6 and Java EE 5 support (JDBC 4.0, JTA 1.1, JavaMail 1.4, JAX-WS 2.0)
Full-featured annotation-driven dependency injection, including support for 'qualifiers' (注意这里只是说完整支持标注驱动的依赖注入, 而不是 complete supported annotation of all features)
Support for auto-detecting application components in the classpath and auto-configuring them as Spring managed objects
A new bean name pointcut element in AspectJ pointcut expressions
Built-in support for AspectJ load-time weaving based on the LoadTimeWeaver abstraction
New XML configuration namespaces "context" and "jms", for maximum convenience
A completely revised integration test framework, with first-class support for JUnit 4 and TestNG
A new annotation-based controller model for Spring MVC supporting Servlet and Portlet environments
Extended SimpleJdbcTemplate functionality, including support for named SQL parameters
Officially certified WebSphere support
The packaging of Spring Framework jars as OSGi-compliant bundles out of the box
The ability to deploy a Spring ApplicationContext as a JCA RAR file, for headless application modules
JCA 1.5 message endpoint management, for Spring-managed JMS and CCI message listeners

小小的兴奋了一把, 最后又不得不归于失望, 继续研究 XML 文件的编写格式吧. 希望下次看到类似消息的时候能翻译的准确一些, 免得误导偶等开源软件"消费者".

 

当然了, 也欢迎 Spring 2.5 高人们向偶分享完全使用标注的例子代码, 那样的话我真是太感谢了!



BeanSoft 2007-11-23 18:14 发表评论
]]>钱啊钱 当 Spring 的首页充斥了培训信息http://www.blogjava.net/beansoft/archive/2007/11/06/158490.htmlBeanSoftBeanSoftTue, 06 Nov 2007 03:48:00 GMThttp://www.blogjava.net/beansoft/archive/2007/11/06/158490.htmlhttp://www.blogjava.net/beansoft/comments/158490.htmlhttp://www.blogjava.net/beansoft/archive/2007/11/06/158490.html#Feedback8http://www.blogjava.net/beansoft/comments/commentRss/158490.htmlhttp://www.blogjava.net/beansoft/services/trackbacks/158490.html
Welcome to the home of the Spring Framework, the leading full-stack Java/JEE application framework. Led and sustained by Interface21, Spring delivers significant benefits for many projects, increasing development productivity and runtime performance while improving test coverage and application quality.

Article: Introduction to the Spring Framework 2.5

Submitted by Nicole Konicki on Tue, 2007-10-30 10:38. Technical Article

In this TSS article, Rod Johnson explains what Spring sets out to achieve and how it can help the community develop enterprise Java applications.

» login or register to post comments

Spring Framework Training Summary (November)

Submitted by Colin Sampaleanu on Thu, 2007-11-01 16:00. News and Announcements
Interface21 is pleased to offer a number of Spring Framework 2.0 and AOP training events in the upcoming period, delivered by the people who build and sustain the Spring Framework. For full details, please visit the main training information page. Here is a summary of some of the upcoming courses and venues:

... plus others

Interested in a full-course of Spring during Winter? The Spring Experience 2007 conference is taking place in sunny Hollywood, Florida, from Dec. 12th-15th.

» login or register to post comments

今天去 http://www.springframework.org/ 看了一眼, 很不幸的首页充斥了培训信息, 还有在中国的...

其实 Spring 的法律上的版权所有者: Interface21 公司, 是有他们自己的网站的. 不过, 开源软件不等于放弃版权, 这个大家一定要清楚啊. 让一个 .org 的网站充满了这样的信息, 真是一种悲哀. 钱, 钱, 钱....



BeanSoft 2007-11-06 11:48 发表评论
]]>使用 HibernateTemplate 实现分页查询http://www.blogjava.net/beansoft/archive/2007/10/10/151702.htmlBeanSoftBeanSoftWed, 10 Oct 2007 05:07:00 GMThttp://www.blogjava.net/beansoft/archive/2007/10/10/151702.htmlhttp://www.blogjava.net/beansoft/comments/151702.htmlhttp://www.blogjava.net/beansoft/archive/2007/10/10/151702.html#Feedback2http://www.blogjava.net/beansoft/comments/commentRss/151702.htmlhttp://www.blogjava.net/beansoft/services/trackbacks/151702.html最近有同学做项目的时候发现 Spring 整合 Hibernate 时候用的 HibernateTemplate 不支持分页, 上网搜了搜找到结果并测试成功, 只需要用下面的方法就能分页:

/**
* 使用hql 语句进行操作
* @param hql HSQL 查询语句
* @param offset 开始取数据的下标
* @param length 读取数据记录数
* @return List 结果集
*/
public List getListForPage(final String hql, final int offset,
 final int length) {

List list = getHibernateTemplate().executeFind(new HibernateCallback() {
 public Object doInHibernate(Session session)
 throws HibernateException, SQLException {
 Query query = session.createQuery(hql);
 query.setFirstResult(offset);
 query.setMaxResults(length);
 List list = query.list();
 return list;
 }
});
return list;
}


BeanSoft 2007-10-10 13:07 发表评论
]]>MyEclipse 5.5 开发 Spring + Struts + Hibernate 的详解视频(长1.5小时)http://www.blogjava.net/beansoft/archive/2007/10/07/150877.htmlBeanSoftBeanSoftSun, 07 Oct 2007 10:16:00 GMThttp://www.blogjava.net/beansoft/archive/2007/10/07/150877.htmlhttp://www.blogjava.net/beansoft/comments/150877.htmlhttp://www.blogjava.net/beansoft/archive/2007/10/07/150877.html#Feedback23http://www.blogjava.net/beansoft/comments/commentRss/150877.htmlhttp://www.blogjava.net/beansoft/services/trackbacks/150877.html第一部分: Struts 开发 6.83MB 22分36秒 http://beansoft.java-cn.org/download/ssh_1_struts.exe

第二部分: Hibernate + Spring 11.5MB 38分59秒 http://beansoft.java-cn.org/download/ssh_2_hibernate_spring.exe

第三部分: 自己实现 SpringProxyAction 5.05MB 14分25秒 http://beansoft.java-cn.org/download/ssh_3_struts_proxy_asm.exe

第四部分: ASM 错误解决及用 Spring 的代理实现整合 9.95MB 23分49秒 http://beansoft.java-cn.org/download/ssh_4_spring_struts.exe

大纲 PDF 下载: http://beansoft.java-cn.org/download/spring_struts_hibernate.pdf 427KB

代码下载(不带类库): http://beansoft.java-cn.org/download/myssh.rar 45KB

 

视频大纲:

Java EE 讲座

MyEclipse 5.5 开发 Spring 整合 Struts, Hibernate 的应用

刘长炯

2007.10

本章要点

*创建数据库

*快速开发 Struts 应用

*添加 Hibernate 功能

*添加 Spring 功能

*Spring 整合 Hibernate

*模拟 Action 代理类实现 Struts + Spring

*Spring 整合 Struts

*Asm 出错和 log4j.properties 文件

*测试运行

创建数据库

• 创建数据库

Ø 用 MyEclipse Derby 或者其它数据库
Ø 用 MyEclipse Database Explorer 管理数据库
Ø 执行 SQL:
• CREATE TABLE bbsuser (
• id int(11) NOT NULL,
• username varchar(200) NOT NULL,
• password varchar(20) NOT NULL,
• age int,
• PRIMARY KEY (id)
• )
• ENGINE=MyISAM DEFAULT CHARSET=GBK;

快速开发 Struts 应用

添加 Hibernate 功能

添加 Spring 功能

Spring 整合 Hibernate

Spring 整合 Hibernate(续)

模拟 Action 代理类实现 Struts + Spring

Spring 整合 Struts

• 添加 Spring Plug in

Ø <plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
Ø <set-property property="contextConfigLocation" value="/WEB-INF/classes/applicationContext.xml" />
Ø </plug-in>

• 替换 Action 的 Type

Ø <action path="/login“ …
Ø type="org.springframework.web.struts.DelegatingActionProxy" />

• 在 Spring 配置文件中配置 Bean

Ø 要点: 通过 path 和 bean 的 name 进行匹配, 这两个值必须一样
Ø <bean name="/login" class="com.test.struts.action.LoginAction"></bean>

• 注入 DAO 的代理 bean

• 详细步骤参考文档

Spring 整合 Struts 的两种方式

• struts1加载spring的两种方式：
第一种：通过web.xml配置加载spring上下文环境，其配置方式如下：
web.xml
     <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/applicationContext.xml</param-value>
      </context-param>
通过listener加载
<listener>
            <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
      </listener>
或者利用severlet类加载
<servlet>
            <servlet-name>context</servlet-name> 
            <servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>
            <load-on-startup>1</load-on-startup> 
        </servlet>
第二种方式：
使用Struts插件
在struts-config.xml中
<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
        <set-property property="contextConfigLocation"
            value="/WEB-INF/applicationContext.xml"/>
    </plug-in>

• 这两种配置的明显区别就是，第一种方式可以配置多个spring配置文件。

Asm 出错和 log4j.properties 文件

• Log4j.properties

Ø # Configure logging for testing: optionally with log file
Ø log4j.rootLogger=WARN, stdout
Ø # log4j.rootLogger=WARN, 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.FileAppender
Ø log4j.appender.logfile.File=target/spring.log
Ø log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
Ø log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

• 删除 asm-2.2.3.jar

测试运行

• 测试运行

Ø 用 MyEclipse 发布到 Tomcat
Ø 运行
Ø 打开浏览器测试

本章小结

• 整合要点

• ASM出错的解决方案

• Q and A?

截图:

PPT

image

视频:

image



BeanSoft 2007-10-07 18:16 发表评论
]]>转载: Eclipse插件之Spring IDEhttp://www.blogjava.net/beansoft/archive/2007/10/02/150127.htmlBeanSoftBeanSoftMon, 01 Oct 2007 16:09:00 GMThttp://www.blogjava.net/beansoft/archive/2007/10/02/150127.htmlhttp://www.blogjava.net/beansoft/comments/150127.htmlhttp://www.blogjava.net/beansoft/archive/2007/10/02/150127.html#Feedback0http://www.blogjava.net/beansoft/comments/commentRss/150127.htmlhttp://www.blogjava.net/beansoft/services/trackbacks/150127.html
Eclipse插件之Spring IDE http://dev2dev.bea.com.cn/bbsdoc/20060810313.html

时间：2006-08-10
作者：俞黎敏
浏览次数： 10905
本文关键字：Eclipse, WebLogic, 部署, 插件, Plugin, Spring, IDE
文章工具
推荐给朋友 推荐给朋友
打印文章 打印文章

　　本文介绍如何利用Eclipse插件Spring IDE在Eclipse中的使用。

　　Eclipse是目前非常流行的开发平台，开放扩展的架构让很多程序员找到了自己个性化的工作环境。

　　问题提出：

　　在采用Spring框架进行系统开发时，Bean的配置文件XML的书写、XML文件的内容校验及Bean之间的依赖关系查看等工作，如果能够采用合适的工具来完成，会成倍提高开发效率。

　　解决方法：

　　Spring IDE是Spring官方网站推荐的Eclipse插件，可提供在开发Spring时对Bean定义文件进行验证并以可视化的方式查看各个Bean之间的依赖关系等。

　　同时，建议结合Eclipse XMLBuddy插件进行XML文件编辑与校验，是个不错的选择。

安装说明

　　JDK：1.5.0　　　　　从http://java.sun.com上去下载安装

　　Eclipse：3.1.2　　　从http://www.eclipse.org 上去下载解压

　　Spring 1.2.8　　　　从http://www.springframework.org 上去下载解压

　　Spring IDE 1.3.2　　从http://springide.org 上去下载

　　XMLBuddy 2.0.72　　从http://www.xmlbuddy.com/ 上去下载

　　Spring IDE 1.3.2 Update地址为：http://springide.org/updatesite/

管理技巧

Eclipse使用技巧之插件管理

　　提示：新下载的插件PlugIn一定不要都放在原始的Eclipse目录下去，一大堆，累死你：（

  1. 前提是你已经下载解压并设置好Eclipse工具，比如解压在E:\OpenSource\Eclipse\目录下，以下这个目录以%ECLIPSE_HOME%来进行表示；
  2. 此时默认的插件是在%ECLIPSE_HOME%\plugins目录中的；
  3. 在%ECLIPSE_HOME%下建立一个PlugInsNew的目录；

    　　比如：E:\OpenSource\Eclipse\PlugInsNew

  4. 如果你下载了一个新的插件，比如叫做：XYZ

    　　那么就在%ECLIPSE_HOME%\PlugInsNew\目录下建立XYZ目录，目录里面是eclipse目录，eclipse目录包含有features与plugins两个子目录；结构如下图所示：

    图1

  5. 把下载的新插件的文件放在以下相应目录中；

    　　%ECLIPSE_HOME%\PlugInsNew\XYZ\eclipse\features

    　　%ECLIPSE_HOME%\PlugInsNew\ XYZ\eclipse\plugins

  6. 建立相关的.link的文件；

    　　然后在%ECLIPSE_HOME%\links目录里建立一个XYZ.link的文件

    　　内容如是：

    　　path=E:/OpenSource/Eclipse/PlugInsNew/XYZ

    　　就一行这样的路径指示而已。

    　　这样，如果你下载了多个插件就可以如法炮制建立多个Link文件，想加载哪个插件就把哪个插件的Link文件放到%ECLIPSE_HOME%\links的目录中即可，使用与管理都很方便，建议千万不要放在默认的安装目录中，这样对于升级Eclipse主程序也方便一些；当然如果你喜欢用Find and Install…进行安装的话也可以的；

    　　如果上面你的%ECLIPSE_HOME%与此不同，请修改XYZ.link文件里的路径。

  7. 删除插件，先关闭Eclipse；

    　　删除%ECLIPSE_HOME%\links\XYZ.link文件即可

    　　删除%ECLIPSE_HOME%\PlugInsNew\XYZ整个目录及文件

  8. 重新启动Eclipse，这样就可以了。如果插件没有生效或者没有删除，请加上-clean进行启动Eclipse，即Eclipse.exe –clean
  9. 插件安装验证及记录详见：Eclipse的workspace下面的.metadata\.log文件，比如：%ECLIPSE_HOME%\workspace\.metadata\.log文件，有问题的话，打开这个文件看看并进行解决。

确认安装

　　此插件安装方法采用上一节的《Eclipse使用技巧之插件管理》

　　重新启动Eclipse后，在Help è About Eclipse SDK è Plug-in Details你可以看到由“Spring IDE Developer”提供的“Spring IDE”版本为“1.3.2”插件及相关的Graph、UI及UI Search插件，如下图所示：

图2

相关要求

　　注意：为了让Spring IDE插件能够显示可视化的Bean结构图形及Bean之间的依赖关系，需要Eclipse GEF(Graphical Editing Framework)的支持，自己下载并解压安装，安装技巧同上《Eclipse使用技巧之插件管理》。

　　Spring 1.2系列当前最新的稳定版本为1.2.8，下载时可以选择包含Spring所依赖的一些开源包的文件spring-framework-1.2.8-with-dependencies.zip，如果你已经清楚并有了Spring所依赖的相关开源包，就单独下载spring-framework-1.2.8.zip即可。建议下载前者。

　　解压后目录结构及包的说明如下：

图3

　　dist目录下是Spring的发布包，关于发布包下面会详细进行说明；

　　docs目录下是相关的文档，包括有Spring api的javadoc、reference参考指南、Spring的taglib标签使用文件及Spring MVC的MVC-step-by-step讲解与示例；

　　lib目录下是Spring所依赖的第三方开源包；

　　mock目录下是Spring辅助应用测试的Mock源程序；

　　samples目录下是Spring的示例源程序及简单的webapp示例框架的示例配置，值得好好学习的有jpetstore及petclinic，当然其它的countries、imagedb、tiles-example也可以好好参考一下；

　　src目录下是Spring的源程序；

　　test目录下Spring的单元测试源程序；

　　tiger目录下是Java 1.5 Tiger方面的相关及测试源程序。

Spring包结构说明

　　接下来详细说说dist目录下jar包的相关内容

　　spring.jar是包含有完整发布的单个jar包，spring.jar中除了spring-mock.jar里所包含的内容外其它所有jar包的内容，因为只有在开发环境下才会用到spring-mock.jar来进行辅助测试，正式应用系统中是用不得这些类的。

　　除了spring.jar文件，Spring还包括有其它13个独立的jar包，各自包含着对应的Spring组件，用户可以根据自己的需要来选择组合自己的jar包，而不必引入整个spring.jar的所有类文件。

　　spring-core.jar

　　这个jar文件包含Spring框架基本的核心工具类，Spring其它组件要都要使用到这个包里的类，是其它组件的基本核心，当然你也可以在自己的应用系统中使用这些工具类。

　　spring-beans.jar

　　这个jar文件是所有应用都要用到的，它包含访问配置文件、创建和管理bean以及进行Inversion of Control / Dependency Injection（IoC/DI）操作相关的所有类。如果应用只需基本的IoC/DI支持，引入spring-core.jar及spring-beans.jar文件就可以了。

　　spring-aop.jar

　　这个jar文件包含在应用中使用Spring的AOP特性时所需的类。使用基于AOP的Spring特性，如声明型事务管理（Declarative Transaction Management），也要在应用里包含这个jar包。

　　spring-context.jar

　　这个jar文件为Spring核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类，JDNI所需的全部类，UI方面的用来与模板（Templating）引擎如Velocity、FreeMarker、JasperReports集成的类，以及校验Validation方面的相关类。

　　spring-dao.jar

　　这个jar文件包含Spring DAO、Spring Transaction进行数据访问的所有类。为了使用声明型事务支持，还需在自己的应用里包含spring-aop.jar。

　　spring-hibernate.jar

　　这个jar文件包含Spring对Hibernate 2及Hibernate 3进行封装的所有类。

　　spring-jdbc.jar

　　这个jar文件包含对Spring对JDBC数据访问进行封装的所有类。

　　spring-orm.jar

　　这个jar文件包含Spring对DAO特性集进行了扩展，使其支持 iBATIS、JDO、OJB、TopLink，因为Hibernate已经独立成包了，现在不包含在这个包里了。这个jar文件里大部分的类都要依赖spring-dao.jar里的类，用这个包时你需要同时包含spring-dao.jar包。

　　spring-remoting.jar

　　这个jar文件包含支持EJB、JMS、远程调用Remoting（RMI、Hessian、Burlap、Http Invoker、JAX-RPC）方面的类。

　　spring-support.jar

　　这个jar文件包含支持缓存Cache（ehcache）、JCA、JMX、邮件服务（Java Mail、COS Mail）、任务计划Scheduling（Timer、Quartz）方面的类。

　　spring-web.jar

　　这个jar文件包含Web应用开发时，用到Spring框架时所需的核心类，包括自动载入WebApplicationContext特性的类、Struts与JSF集成类、文件上传的支持类、Filter类和大量工具辅助类。

　　spring-webmvc.jar

　　这个jar文件包含Spring MVC框架相关的所有类。包含国际化、标签、Theme、视图展现的FreeMarker、JasperReports、Tiles、Velocity、XSLT相关类。当然，如果你的应用使用了独立的MVC框架，则无需这个JAR文件里的任何类。

　　spring-mock.jar

　　这个jar文件包含Spring一整套mock类来辅助应用的测试。Spring测试套件使用了其中大量mock类，这样测试就更加简单。模拟HttpServletRequest和HttpServletResponse类在Web应用单元测试是很方便的。

　　如何选择这些发布包，决定选用哪些发布包其实相当简单。如果你正在构建Web应用并将全程使用Spring，那么最好就使用单个全部的spring.jar文件；如果你的应用仅仅用到简单的Inversion of Control / Dependency Injection（IoC/DI）容器，那么只需spring-core.jar与spring-beans.jar即可；如果你对发布的大小要求很高，那么就得精挑细选了，只取包含自己所需特性的jar文件了。采用独立的发布包你可以避免包含自己的应用不需要的全部类。当然你可以采用其它的一些工具来设法令整个应用包变小，节省空间的重点在于准确地找出自己所需的Spring依赖类，然后合并所需的类与包就可以了。Eclispe有个插件叫ClassPath Helper可以帮你找找所依赖的类。

Spring包依赖说明 

　　spring-core.jar需commons-collections.jar，spring-core.jar是以下其它各个的基本。

spring-beans.jar需spring-core.jar/cglib-nodep-2.1_3.jar
spring-aop.jar需spring-core.jar/spring-beans.jar/cglib-nodep-2.1_3.jar/aopalliance.jar
spring-context.jar需
spring-core.jar/spring-beans.jar/spring-aop.jar/commons-collections.jar/aopalliance.jar

spring-dao.jar需spring-core.jar/spring-beans.jar/spring-aop.jar/spring-context.jar
spring-jdbc.jar需spring-core.jar/spring-beans.jar/spring-dao.jar
spring-web.jar需spring-core.jar/spring-beans.jar/spring-context.jar
spring-webmvc.jar需spring-core.jar/spring-beans.jar/spring-context.jar/spring-web.jar
spring-hibernate.jar需
spring-core.jar/spring-beans.jar/spring-aop.jar/spring-dao.jar/spring-jdbc.jar/spring-orm.jar/spring-web.jar/spring-webmvc.jar
spring-orm.jar需
spring-core.jar/spring-beans.jar/spring-aop.jar/spring-dao.jar/spring-jdbc.jar/spring-web.jar/spring-webmvc.jar
spring-remoting.jar需
spring-core.jar/spring-beans.jar/spring-aop.jar/spring-dao.jar/spring-context.jar/spring-web.jar/spring-webmvc.jar
spring-support.jar需
spring-core.jar/spring-beans.jar/spring-aop.jar/spring-dao.jar/spring-context.jar/spring-jdbc.jar

spring-mock.jar需spring-core.jar/spring-beans.jar/spring-dao.jar/spring-context.jar/spring-jdbc.jar

插件介绍

　　我们简单地创建一个示例工程，里面包含有一个接口类与两个实现该接口的实现类进行演示说明使用的方法。

　　需要引入spring.jar、commons-logging.jar、log4j.jar

　　单个引入需要引入spring-core.jar、spring-beans.jar、spring-context.jar

　　接口类：IHelloWorld.java

　　public interface  IHelloWorld
{
   String sayHelloWorld();
}

　　实现类一：HelloWorld1.java

　　public class HelloWorld1 implements IHelloWorld
{
	public HelloWorld1()
	{
		super();
	}

	public String sayHelloWorld()
	{
		return "Hello World HelloWorld1";
	}
}

　　实现类二：HelloWorld2.java

　　public class HelloWorld2 implements IHelloWorld
{
	public HelloWorld2()
	{
		super();
	}

	public String sayHelloWorld()
	{
		return "Hello World HelloWorld2";
	}
}

　　根据常用的三层与Spring的最佳实践，将配置文件分成了四个

　　beanRefFactory.xml负责总装，由SingletonBeanFactoryLocator来装入

　　通过ClassPathXmlApplicationContext来把其它三个模块的文件引入

　　beanRefDataAccess.xml负责DAO，与数据库相关的bean都定义在这里

　　beanRefService.xml负责Service层的bean定义

　　beanRefMVC.xml负责Spring MVC方面相关的bean定义等等

　　以下配置文件的bean定义为演示所用，各自的内容如下：

　　beanRefFactory.xml的内容如下：

　　<xml version="1.0" encoding="UTF-8">
<!DOCTYPE beans PUBLIC 	"-//SPRING//DTD BEAN//EN" 
	"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
<bean id="beanFactory" class="org.springframework.context.support.ClassPathXmlApplicationContext">
<constructor-arg>
<list>
<value>beanRefDataAccess.xml</value>
<value>beanRefService.xml</value>
<value>beanRefMVC.xml</value>
</list>
</constructor-arg>
</bean>
</beans>

　　beanRefDataAccess.xml的内容如下：

　　<xml version="1.0" encoding="UTF-8">
<!DOCTYPE beans PUBLIC 	"-//SPRING//DTD BEAN//EN" 
	"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
	<bean id="helloWorldDAO1" class="HelloWorld1"/>
	<bean id="helloWorldDAO2" class="HelloWorld2"/>
</beans>

　　beanRefService.xml的内容如下：

　　<xml version="1.0" encoding="UTF-8">
<!DOCTYPE beans PUBLIC 	"-//SPRING//DTD BEAN//EN" 
	"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
	<bean id="helloWorld1" class="HelloWorld1"/>
	<bean id="helloWorld2" class="HelloWorld2"/>
	<bean id="springDemoConstructor" class="SpringDemoConstructor">
		<constructor-arg>
			<value>Spring IDE Constructor</value>
		</constructor-arg>
		<property name="helloWorld">
			<ref bean="helloWorld1"></ref>
		</property>
	</bean>
	<bean id="springDemoSetter" class="SpringDemoSetter">
		<property name="hello" value="Spring IDE Setter"/>
		<property name="helloWorld">
			<ref bean="helloWorld2"></ref>
		</property>
	</bean>
</beans>

　　beanRefMVC.xml的内容如下：

　　<xml version="1.0" encoding="UTF-8">
<!DOCTYPE beans PUBLIC 
	"-//SPRING//DTD BEAN//EN" 
	"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
	<bean id="helloWorldMVC1" class="HelloWorld1"/>
	<bean id="helloWorldMVC2" class="HelloWorld2"/>
</beans>

　　右键项目工程：可以看到“Add Spring Project Nature”菜单，单击它

图4

　　细心的你一定可以看到项目工程SpringIDEDemo前面的图标变成了一个S的标志，而不是原来的J，当然项目里与Spring相关的文件都会在图标上显示一个S标志。J

　　右键弹出的菜单里就会有个“Remove Spring Project Nature”的菜单了。

　　你选择这个菜单进行移除后就不能进行以下的相关操作了。

图5

　　Window è Show View è Other… è 可以看到Spring IDE，打开它，如下所示，所中它并确定。

图6

　　可以看到如下的视图，右键工程的名称，在弹出的Properties菜单上点击它

图7

　　弹出属性框，让我们来添加配置文件

图8

　　确定后，可以看到刚才选择的四个配置文件已经在里面了，再次确定。

图9

　　在Spring Beans视图里展开工程后，便可以看到增加进来的四个配置文件了。

图10

　　也可以将配置文件放到配置集合里，如下所示：

图11

　　这样确定以后，可以看到四个文件都属于Service的节点下面，如下所示。

图12

　　再次确定后，在Spring Beans视图里看到Service节点，展开它，可以看到所有配置文件里的bean都在这里列出来了。

图13

　　展开显示两个定义的bean结点，右键其中的一个结点，弹出四个菜点，最后一个就是上面的配置菜单，不再讲解了，我们选中“Open Config File”菜单

图14

　　于是就会自动打开配置文件，并定位到bean的定义位置上面去了，如下所示，方便进行查看与改动。

图15

　　在右键弹出的菜单点选中“Open Bean Class”，

图16

　　就会自动定位到对应的类文件里去了，如下所示。

图17

　　在右键弹出的菜单点选中“Show Graph”，

图18

　　就会把当前这个bean以图形的方式显示出来，如下所示。

图19

　　但是这个演示的文件仅是一个独立的bean，没有任何关联等，下面会演示关联等。

　　在Spring Beans视图里展开工程后，选中src/beanRefSerice.xml配置文件，在右键弹出的菜单点选中“Show Graph”

图20

　　就会把当前整个配置文件的内容以bean图形的方式显示出来，如下所示。

图21

　　以下演示bean的引用及构造注入与setter注入何关联等，更多的操作类似了。

　　定义一个接口类ISpringDemo.java，有两个方法

　　public interface ISpringDemo
{
	IHelloWorld getHelloWorld();
	String getHello();
}

　　实现类一SpringDemoConstructor.java，含有构造注入及setter注入

　　public class SpringDemoConstructor implements ISpringDemo
{
	private String hello;
	private IHelloWorld helloWorld;
	
	public SpringDemoConstructor(String hello)
	{
		this.hello = hello;
	}
	
	public String getHello()
	{
		return hello;
	}

	public IHelloWorld getHelloWorld()
	{
		return helloWorld;
	}

	public void setHelloWorld(IHelloWorld helloWorld)
	{
		this.helloWorld = helloWorld;
	}
}

　　实现类二SpringDemoSetter.java，都是setter注入

　　public class SpringDemoSetter implements ISpringDemo
{
	private String hello;
	private IHelloWorld helloWorld;

	public String getHello()
	{
		return hello;
	}

	public void setHello(String hello)
	{
		this.hello = hello;
	}

	public IHelloWorld getHelloWorld()
	{
		return helloWorld;
	}

	public void setHelloWorld(IHelloWorld helloWorld)
	{
		this.helloWorld = helloWorld;
	}
}

　　配置文件beanRefService.xml增加bean定义，成为如下，红字为新增的

　　<xml version="1.0" encoding="UTF-8">
<!DOCTYPE beans PUBLIC 
	"-//SPRING//DTD BEAN//EN" 
	"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
	<bean id="helloWorld1" class="HelloWorld1"/>
	<bean id="helloWorld2" class="HelloWorld2"/>
	<bean id="springDemoConstructor" class="SpringDemoConstructor">
		<constructor-arg>
			<value>Spring IDE Constructor</value>
		</constructor-arg>
		<property name="helloWorld">
			<ref bean="helloWorld1"></ref>
		</property>
	</bean>
	<bean id="springDemoSetter" class="SpringDemoSetter">
		<property name="hello" value="Spring IDE Setter"/>
		<property name="helloWorld">
			<ref bean="helloWorld2"></ref>
		</property>
	</bean>
</beans>

　　注意：

　　如果bean是定义在同一个文件里的可以用

　　<ref local="helloWorld2"></ref>

　　如果不是在同一个配置文件里的，要用

　　<ref bean="helloWorld2"></ref>

　　要不然会报到bean找不到！

　　这样配置完成后，我们切换到“Spring Beans”视图，在beanRefService.xml节点上右键打开“Show Graph”菜单，可以看到如下所示：

图21

　　这时bean里面简单的引用关系就表现出来了。

图22

　　在bean图上右键，会打开三个操作菜单：

　　Open Java Type即定位到bean的类文件上面；

　　Open Config File即定位到bean的xml配置文件上面；

　　Show In Beans View即定位到“Spring Beans”的视图里的具体某个节点上，如下所示。

图23

　　此时我们可以在配置集合的Service节点上面右键，选择“Show Graph”

图24

　　这样就会显示出所有的配置文件集合里的所有bean文件及其关联引用情况，如下图。

图25

　　带圈的P图标表示是属性，即setter方法注入，带圈的C图标表示构造注入。箭头表示引用关系了。J

　　中间一排演示用的四个bean没有关联引入，就光杆司令地在那里排队了啦J

　　最下面的带圈的C后面又跟着一大排参数，表示集合类型的了。如list

　　Spring IDE提供错误检查功能，比如我在配置文件中输入一个不存在的类的名称，保存后，就会在边上出现红色提示，鼠标移上去就会出现提示信息，如下图所示。

图26

　　当然也会有Problems视图里显示相应的错误信息，如下图：

图27

　　XMLBuddy

　　由于打开XML文件时会根据XML文件里定义的DTD去网上查找相应的DTD文件，这样导至打开的时候会相当慢，特别是如果你的机器上不了外网的话，就更慢了。

　　解决的办法有两个：

　　一、在本机开启Web服务（如Tomcat等等），并设置端口为80，然后根据DTD 的目录结构建立相应的结构，并把DTD文件放进去。然后在hosts文件里把本机的地址映射到相应的DTD指定的网站去，如：

　　127.0.0.1// www.springframework.org

　　这样打开XML文件时就会在本机寻找DTD文件进行验证，速度就快很多了J

　　二、打开XMLBuddy插件的安装目录，并找到其中的cache目录，比如：%ECLIPSE_HOME%\PlugInsNew\xmlbuddy\eclipse\plugins\com.objfac.xmleditor_2.0.72\.cache

　　打开meta.xml文件，一看就知道怎么处理了吧，如法炮制，选把DTD文件拷贝到这个cache目录里，再增加内容到meta.xml里来，比如：

　　<file>
<pub>-//SPRING//DTD  BEAN//EN</pub>
<abs>http://www.springframework.org/dtd/spring-beans.dtd</abs>
<rel>spring-beans.dtd</rel>
</file>

　　要增加其它的DTD文件方法类似，不断地增加说明与DTD文件即可。

　　于是在编辑XML文件时就会有相关的提示及错误提示信息，可以减少一些书写XML文件时发生的低级错误了。

图28

　　测试与运行

　　先建立一个Log4J的配置文件log4j.properties，内容如下

　　# Set root logger level to ERROR and its only appender to R.
log4j.rootLogger = INFO,R

# R is set to be a DailyRollingFileAppender.
log4j.appender.R = org.apache.log4j.DailyRollingFileAppender

log4j.appender.R.File = Application.log
log4j.appender.R.DatePattern = yyyy-MM-dd'.log'
log4j.appender.R.layout = org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern = %-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n

　　再创建一个ServiceFactory.java静态类，用来做单元测试方便一些

　　import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.access.BeanFactoryLocator;
import org.springframework.beans.factory.access.BeanFactoryReference;
import org.springframework.beans.factory.access.SingletonBeanFactoryLocator;

public final class ServiceFactory
{
	private static BeanFactoryLocator bfLocator = null;
	private static BeanFactoryReference bfReference = null;
	private static BeanFactory factory = null;
	static
	{
		bfLocator = SingletonBeanFactoryLocator.getInstance();
		bfReference = bfLocator.useBeanFactory("beanFactory");
		factory = bfReference.getFactory();
	}
	
	private ServiceFactory()
	{
		super();
	}

	public static Object getBeanByName(final String beanName)
	{
		return factory.getBean(beanName);
	}
}

　　做成静态的这样我们可以ServiceFactory .getBeanByName(“beanname”)就可以得到相应的bean了。

　　测试类SpringIDETest.java代码如下：

　　import junit.framework.TestCase;

public class SpringIDETest extends TestCase
{
	private IHelloWorld helloWorld = null;
	private ISpringDemo springDemo = null;
	private final static String hello1 = "Hello World HelloWorld1";
	private final static String hello2 = "Hello World HelloWorld2";
	private final static String helloset = "Spring IDE Setter";
	private final static String hellocon = "Spring IDE Constructor";

	public void testSpringBeans()
	{
		helloWorld = (IHelloWorld)ServiceFactory.getBeanByName("helloWorld1");
		assertEquals(hello1,helloWorld.sayHelloWorld());
		helloWorld = (IHelloWorld)ServiceFactory.getBeanByName("helloWorld2");
		assertEquals(hello2,helloWorld.sayHelloWorld());
	}
	public void testIoCConstructor()
	{
		//Constructor
		springDemo = (ISpringDemo)ServiceFactory.getBeanByName("springDemoConstructor");
		assertEquals(hellocon,springDemo.getHello());
		assertEquals(hello1,springDemo.getHelloWorld().sayHelloWorld());
	}
	public void testIoCSetter()
	{
		//Setter
		springDemo = (ISpringDemo)ServiceFactory.getBeanByName("springDemoSetter");
		assertEquals(helloset,springDemo.getHello());
		assertEquals(hello2,springDemo.getHelloWorld().sayHelloWorld());
	}
}

　　　　Run As JUnit Test之，绿色打勾全部通过就收工走人了。。。J

　　当然也可以打开Application.log文件查看输出一些什么信息。

使用总结

　　此插件的功能不错：）对于Spring这样优雅的框架来说，再加上这个助手，真的是很美很美了，美美地喝上一杯咖啡吧。J （讨论或查看原贴）

dot dot dot

dot
  作者其它文章


BeanSoft 2007-10-02 00:09 发表评论
]]>(Spring 学习)Spring 发布时所需的最小包依赖http://www.blogjava.net/beansoft/archive/2007/09/22/147380.htmlBeanSoftBeanSoftSat, 22 Sep 2007 05:01:00 GMThttp://www.blogjava.net/beansoft/archive/2007/09/22/147380.htmlhttp://www.blogjava.net/beansoft/comments/147380.htmlhttp://www.blogjava.net/beansoft/archive/2007/09/22/147380.html#Feedback0http://www.blogjava.net/beansoft/comments/commentRss/147380.htmlhttp://www.blogjava.net/beansoft/services/trackbacks/147380.htmlCopy the following files into the library directory:
- spring.jar
- commons-logging.jar
- servlet-api.jar
 
web.xml
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd">
<!--
  - Web app deployment descriptor that just loads an "example" DispatcherServlet
  - with a specific context.
  -
  - Depends on the following libraries in WEB-INF/lib:
  - * spring.jar
  - * commons-logging.jar
  -->
<web-app>
  <!--
    - Servlet that dispatches request to registered handlers (Controller implementations).
    - Has its own application context, by default defined in "{servlet-name}-servlet.xml",
    - i.e. "example-servlet.xml".
    -
    - A web app can contain any number of such servlets.
    - Note that this web app does not have a shared root application context,
    - therefore the DispatcherServlet contexts do not have a common parent.
    -->
 <servlet>
  <servlet-name>example</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <load-on-startup>1</load-on-startup>
  </servlet>
  <!--
    - Maps the example dispatcher to /example/*. All handler mappings in
    - example-servlet.xml will by default be applied to this subpath.
    - If a mapping isn't a /* subpath, the handler mappings are considered
    - relative to the web app root.
    -
    - A single dispatcher could get mapped to multiple paths, like any servlet.
    -->
 <servlet-mapping>
    <servlet-name>example</servlet-name>
    <url-pattern>/example/*</url-pattern>
  </servlet-mapping>
 
  <welcome-file-list>
  <welcome-file>index.jsp</welcome-file>
 </welcome-file-list>
</web-app>
 
example-servlet.xml
 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<!--
  - Application context definition for "example" DispatcherServlet.
  -->
<beans>
 <!--
   - Due to the dispatcher mapping in web.xml and the default BeanNameUrlHandlerMapping
   - in this context, "http://localhost/example/test" will trigger this controller.
   -
   - Due to the default InternalResourceViewResolver, returned view names get treated
   - as internal resources, e.g. JSPs: "/test.jsp" or "/WEB-INF/jsp/test.jsp" will
   - render the respective file. So with the default resolver, controllers have to
   - specify the whole resource path as view name (see below for an alternative).
   -
   - HandlerMapping and ViewResolver are simple interfaces: Choose one of Spring's
   - provided implementations, or write your own one.
   -
   - A very simple Controller implementation could look as follows:
   -
   -   public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) {
   -     return new ModelAndView("/test.jsp");
   -   }
   -
   - Or for writing the response directly:
   -
   -   public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) {
   -     response.getWriter().write("This is a test");
   -     return null;
   -   }
    -->
 <bean name="/test" class="example.ExampleController"/>
 <!--
   - Optional: Explicit InternalResourceViewResolver definition,
   - specifying view class, name prefix, and name suffix.
   -
   - Specifying the JstlView class instead of the default InternalResourceView
   - exports Spring's message source and the current user locale as standard
   - JSTL attributes, to be leveraged by JSTL fmt tags.
   -
   - A prefix/suffix combination allows for symbolic view names to be returned
   - by controllers, still getting straightly mapped to internal resources.
   - Example: view name "test" -> resource "/WEB-INF/jsp/test.jsp".
   -
   - For more sophisticated mappings, consider ResourceBundleViewResolver
   - (see "webapp-typical" skeleton) or XmlViewResolver.
   -->
 <!--
 <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
  <property name="viewClass"><value>org.springframework.web.servlet.view.JstlView</value></property>
  <property name="prefix"><value>/WEB-INF/jsp/</value></property>
  <property name="suffix"><value>.jsp</value></property>
 </bean>
 -->
</beans>


BeanSoft 2007-09-22 13:01 发表评论
]]>简单的 BeanFactory 帮助大家理解 Springhttp://www.blogjava.net/beansoft/archive/2007/09/12/144577.htmlBeanSoftBeanSoftWed, 12 Sep 2007 10:22:00 GMThttp://www.blogjava.net/beansoft/archive/2007/09/12/144577.htmlhttp://www.blogjava.net/beansoft/comments/144577.htmlhttp://www.blogjava.net/beansoft/archive/2007/09/12/144577.html#Feedback0http://www.blogjava.net/beansoft/comments/commentRss/144577.htmlhttp://www.blogjava.net/beansoft/services/trackbacks/144577.htmlSpring 是什么, 就是个大 Map.
 
import java.io.InputStream;

import java.util.Enumeration;

import java.util.Hashtable;

import java.util.Map;

import java.util.Properties;



public class BeanFactory {

private static Map<String, Object> objectPool = new Hashtable<String, Object>();

static {

Properties config = new Properties();

InputStream in = BeanFactory.class

.getResourceAsStream("beans-config.properties");

if (in == null) {

throw new ExceptionInInitializerError(

"no file:beans-config found error!");

}

try {

config.load(in);

in.close();

Enumeration ids = config.propertyNames();

while (ids.hasMoreElements()) {

String id = (String) ids.nextElement();

String className = config.getProperty(id);

Object instance = Class.forName(className).newInstance();

objectPool.put(id, instance);

}

} catch (Exception e) {

e.printStackTrace();

throw new ExceptionInInitializerError("failed to init bean pools!");

}

}

public static Object getBean(String id) {

return objectPool.get(id);

}

}


BeanSoft 2007-09-12 18:22 发表评论
]]>Spring + Struts + Hibernate 的完整 MyEclipse 项目源码http://www.blogjava.net/beansoft/archive/2007/09/08/143678.htmlBeanSoftBeanSoftSat, 08 Sep 2007 13:12:00 GMThttp://www.blogjava.net/beansoft/archive/2007/09/08/143678.htmlhttp://www.blogjava.net/beansoft/comments/143678.htmlhttp://www.blogjava.net/beansoft/archive/2007/09/08/143678.html#Feedback4http://www.blogjava.net/beansoft/comments/commentRss/143678.htmlhttp://www.blogjava.net/beansoft/services/trackbacks/143678.htmlhttp://download.gro.clinux.org/beansoft/ssh_full.zip 1.55MB

内含建表语句.

如果出现 404 ActionServlet 错误, 请参考这里:

[置顶]MyEclipse 开发 SSH 整合时 java.lang.NoSuchMethodError: org.objectweb.asm.ClassVisitor.visit 解决方案



BeanSoft 2007-09-08 21:12 发表评论
]]>Spring 整合 Strus 要点http://www.blogjava.net/beansoft/archive/2007/09/08/143674.htmlBeanSoftBeanSoftSat, 08 Sep 2007 12:56:00 GMThttp://www.blogjava.net/beansoft/archive/2007/09/08/143674.htmlhttp://www.blogjava.net/beansoft/comments/143674.htmlhttp://www.blogjava.net/beansoft/archive/2007/09/08/143674.html#Feedback0http://www.blogjava.net/beansoft/comments/commentRss/143674.htmlhttp://www.blogjava.net/beansoft/services/trackbacks/143674.html

Spring 整合 Strus 要点
beansoft@126.com
2007-8-5

1. 项目需要有 Struts 包和 Spring 的 core, aop, web 三个包(注意不是 Spring 自己的 Web MVC), 具体的 .classpath 文件如下所示:

<?xml version="1.0" encoding="UTF-8"?>
<classpath>
    <classpathentry kind="src" path="src"/>
    <classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
    <classpathentry kind="con" path="com.genuitec.eclipse.j2eedt.core.J2EE14_CONTAINER"/>
    <classpathentry kind="lib" path="WebRoot/WEB-INF/lib/antlr.jar"/>
    <classpathentry kind="lib" path="WebRoot/WEB-INF/lib/commons-beanutils.jar"/>
    <classpathentry kind="lib" path="WebRoot/WEB-INF/lib/commons-digester.jar"/>
    <classpathentry kind="lib" path="WebRoot/WEB-INF/lib/commons-fileupload.jar"/>
    <classpathentry kind="lib" path="WebRoot/WEB-INF/lib/commons-logging.jar"/>
    <classpathentry kind="lib" path="WebRoot/WEB-INF/lib/commons-validator.jar"/>
    <classpathentry kind="lib" path="WebRoot/WEB-INF/lib/jakarta-oro.jar"/>
    <classpathentry kind="lib" path="WebRoot/WEB-INF/lib/struts.jar"/>
    <classpathentry kind="lib" path="WebRoot/WEB-INF/lib/mysql-connector-java-3.1.11-bin.jar"/>
    <classpathentry kind="con" path="melibrary.com.genuitec.eclipse.springframework.MYECLIPSE_SPRING20_CORE"/>
    <classpathentry kind="con" path="melibrary.com.genuitec.eclipse.springframework.MYECLIPSE_SPRING20_AOP"/>
    <classpathentry kind="con" path="melibrary.com.genuitec.eclipse.springframework.MYECLIPSE_SPRING20_WEB"/>
    <classpathentry kind="output" path="WebRoot/WEB-INF/classes"/>
</classpath>

2. 对 Struts 配置文件做修改加入 Spring 托管功能.

创建 Spring 配置文件，将文件放到src 目录下，文件名称为 applicationContext.xml, 编译后放到 WEB-INF/classes/ 下.

配置struts-config.xml文件，添加 spring的插件, 位置在 struts-config 文件的最末尾. 

<plug-in className="org.springframework.web.struts.ContextLoaderPlugIn">
<set-property property="contextConfigLocation" value="/WEB-INF/classes/applicationContext.xml" />
</plug-in>

3. 修改 Struts 的 struts-config.xml 中的Action配置

原： 

<action
attribute="loginForm"
input="/login.jsp"
name="loginForm"
path="/login"
scope="request"
validate="true"
type="com.test.struts.action.LoginAction" />

改为： 

<action
attribute="loginForm"
input="/login.jsp"
name="loginForm"
path="/login"
scope="request"
validate="true"
type="org.springframework.web.struts.DelegatingActionProxy" />

type 部份为修改内容, 这里将使用spring的代理器来对Action进行控制.
当提交到/login.do是将控制权交给了spring，然后由spring来把它转回到struts的Action.

4. 配置spring 来实例化上一步中被删除的 Action 类. 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"> 

<beans>
<bean name="/login" class="com.test.struts.action.LoginAction"></bean> 

</beans>

Spring 通过 org.springframework.web.struts.DelegatingActionProxy 这个类, 然后根据 Struts 配置文件中的 <action path="/login" ..> 和 Spring 配置文件中的 <bean name="/login" ..> 来将 Spring 管理下的 Struts Action 类和提交的路径匹配起来, 这些就是关于转交控制权的配置内容.

实践的过程中发现必须把 singleton="false"去掉才行, 否则就会无法初始化 Spring 框架, 不知道具体的原因是什么.

既然这个 Struts 的 Action 已经通过 Spring 来初始化, 所以就可以加入依赖注入, 整合 Hibernate 的功能了. 例如典型的情况: 

com.test.struts.action.LoginAction 

private UserManager userManager; 

public UserManager getUserManager()...
public void setUserManager(UserManager userMgmr) ... 

public ActionForward execute(ActionMapping mapping, ActionForm form,
    HttpServletRequest request, HttpServletResponse response) {
    System.out.println("userManager=" + getUserManager());
    getUserManager().someBusinessMethods();
    .....
}

然后就可以配置: 

<bean name="/login" class="com.test.struts.action.LoginAction">
  <property name="userManager">
   <ref bean="userManagerBean" />
  </property>
</bean> 

<bean id="userManagerBean" class="manager.UserManager" />

同理 Spring 整合 Hibernate 和没 Struts 的时候一样, 也可以在这个文件中进行配置即可.

4. 最后一步, 测试, 只要能打印出来 userManager 不为空, 就说明整合成功了. 如果出现 404 action servlet 不可用的错误, 一般都是 Spring 配置文件出错导致的.

参考视频: 小电影: 用 MyEclipse 开发 Spring + Struts 的总结与操作视频(7分钟)



BeanSoft 2007-09-08 20:56 发表评论
]]>MyEclipse 开发 SSH 整合时 java.lang.NoSuchMethodError: org.objectweb.asm.ClassVisitor.visit 解决方案http://www.blogjava.net/beansoft/archive/2007/08/27/139890.htmlBeanSoftBeanSoftMon, 27 Aug 2007 05:41:00 GMThttp://www.blogjava.net/beansoft/archive/2007/08/27/139890.htmlhttp://www.blogjava.net/beansoft/comments/139890.htmlhttp://www.blogjava.net/beansoft/archive/2007/08/27/139890.html#Feedback8http://www.blogjava.net/beansoft/comments/commentRss/139890.htmlhttp://www.blogjava.net/beansoft/services/trackbacks/139890.html这篇文章解决了问题, 核心提示:

2007-08-08 发现用 MyEclipse 5.5 做 Struts 1.2 + Spring 2.0 + Hibernate 3.1 整合时启动过程中报如下的错误:


2007-08-08 15:36:17,406 ERROR [org.hibernate.proxy.BasicLazyInitializer] - CGLIB Enhancement failed: dao.User
java.lang.NoSuchMethodError: org.objectweb.asm.ClassVisitor.visit(IILjava/lang/String;Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;)V
 at net.sf.cglib.core.ClassEmitter.begin_class(ClassEmitter.java:77)

Spring 和 Hibernate 共用的一些 jar 文件发生了版本冲突, 删除 WEB-INF/lib/asm-2.2.3.jar 然后重启 Tomcat.

asm-2.2.3.jar
       asm.jar
       asm-attrs.jar
      asm-commons-2.2.3.jar
      asm-util-2.2.3.jar


原文参考:　http://heweiya.javaeye.com/blog/101575


下面是一个完整的出错信息:

2007-10-7 10:44:42 org.apache.catalina.core.StandardContext listenerStart
严重: Exception sending context initialized event to listener instance of class org.springframework.web.context.ContextLoaderListener
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'entityManagerFactory' defined in ServletContext resource [/WEB-INF/classes/applicationContext.xml]: Invocation of init method failed; nested exception is java.lang.ExceptionInInitializerError
Caused by: java.lang.ExceptionInInitializerError
at org.hibernate.proxy.pojo.cglib.CGLIBLazyInitializer.getProxyFactory(CGLIBLazyInitializer.java:117)
at org.hibernate.proxy.pojo.cglib.CGLIBProxyFactory.postInstantiate(CGLIBProxyFactory.java:43)
at org.hibernate.tuple.entity.PojoEntityTuplizer.buildProxyFactory(PojoEntityTuplizer.java:162)
at org.hibernate.tuple.entity.AbstractEntityTuplizer.<init>(AbstractEntityTuplizer.java:135)
at org.hibernate.tuple.entity.PojoEntityTuplizer.<init>(PojoEntityTuplizer.java:55)
at org.hibernate.tuple.entity.EntityEntityModeToTuplizerMapping.<init>(EntityEntityModeToTuplizerMapping.java:56)
at org.hibernate.tuple.entity.EntityMetamodel.<init>(EntityMetamodel.java:295)
at org.hibernate.persister.entity.AbstractEntityPersister.<init>(AbstractEntityPersister.java:434)
at org.hibernate.persister.entity.SingleTableEntityPersister.<init>(SingleTableEntityPersister.java:109)
at org.hibernate.persister.PersisterFactory.createClassPersister(PersisterFactory.java:55)
at org.hibernate.impl.SessionFactoryImpl.<init>(SessionFactoryImpl.java:226)
at org.hibernate.cfg.Configuration.buildSessionFactory(Configuration.java:1294)
at org.hibernate.cfg.AnnotationConfiguration.buildSessionFactory(AnnotationConfiguration.java:915)
at org.hibernate.ejb.Ejb3Configuration.buildEntityManagerFactory(Ejb3Configuration.java:730)
at org.hibernate.ejb.HibernatePersistence.createEntityManagerFactory(HibernatePersistence.java:121)
at javax.persistence.Persistence.createEntityManagerFactory(Persistence.java:51)
at org.springframework.orm.jpa.LocalEntityManagerFactoryBean.createNativeEntityManagerFactory(LocalEntityManagerFactoryBean.java:91)
at org.springframework.orm.jpa.AbstractEntityManagerFactoryBean.afterPropertiesSet(AbstractEntityManagerFactoryBean.java:251)
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.invokeInitMethods(AbstractAutowireCapableBeanFactory.java:1202)
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(AbstractAutowireCapableBeanFactory.java:1172)
at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:428)
at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:251)
at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:156)
at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:248)
at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:160)
at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:284)
at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:352)
at org.springframework.web.context.ContextLoader.createWebApplicationContext(ContextLoader.java:244)
at org.springframework.web.context.ContextLoader.initWebApplicationContext(ContextLoader.java:187)
at org.springframework.web.context.ContextLoaderListener.contextInitialized(ContextLoaderListener.java:49)
at org.apache.catalina.core.StandardContext.listenerStart(StandardContext.java:3830)
at org.apache.catalina.core.StandardContext.start(StandardContext.java:4337)
at org.apache.catalina.core.ContainerBase.addChildInternal(ContainerBase.java:791)
at org.apache.catalina.core.ContainerBase.addChild(ContainerBase.java:771)
at org.apache.catalina.core.StandardHost.addChild(StandardHost.java:525)
at org.apache.catalina.startup.HostConfig.deployDirectory(HostConfig.java:920)
at org.apache.catalina.startup.HostConfig.deployDirectories(HostConfig.java:883)
at org.apache.catalina.startup.HostConfig.deployApps(HostConfig.java:492)
at org.apache.catalina.startup.HostConfig.start(HostConfig.java:1138)
at org.apache.catalina.startup.HostConfig.lifecycleEvent(HostConfig.java:311)
at org.apache.catalina.util.LifecycleSupport.fireLifecycleEvent(LifecycleSupport.java:117)
at org.apache.catalina.core.ContainerBase.start(ContainerBase.java:1053)
at org.apache.catalina.core.StandardHost.start(StandardHost.java:719)
at org.apache.catalina.core.ContainerBase.start(ContainerBase.java:1045)
at org.apache.catalina.core.StandardEngine.start(StandardEngine.java:443)
at org.apache.catalina.core.StandardService.start(StandardService.java:516)
at org.apache.catalina.core.StandardServer.start(StandardServer.java:710)
at org.apache.catalina.startup.Catalina.start(Catalina.java:566)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source)
at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source)
at java.lang.reflect.Method.invoke(Unknown Source)
at org.apache.catalina.startup.Bootstrap.start(Bootstrap.java:288)
at org.apache.catalina.startup.Bootstrap.main(Bootstrap.java:413)
Caused by: java.lang.SecurityException: class "org.objectweb.asm.CodeVisitor"'s signer information does not match signer information of other classes in the same package
at java.lang.ClassLoader.checkCerts(Unknown Source)
at java.lang.ClassLoader.preDefineClass(Unknown Source)
at java.lang.ClassLoader.defineClass(Unknown Source)
at java.security.SecureClassLoader.defineClass(Unknown Source)
at org.apache.catalina.loader.WebappClassLoader.findClassInternal(WebappClassLoader.java:1817)
at org.apache.catalina.loader.WebappClassLoader.findClass(WebappClassLoader.java:872)
at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1325)
at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1204)
at java.lang.ClassLoader.loadClassInternal(Unknown Source)
at net.sf.cglib.core.KeyFactory$Generator.generateClass(KeyFactory.java:165)
at net.sf.cglib.core.DefaultGeneratorStrategy.generate(DefaultGeneratorStrategy.java:25)
at net.sf.cglib.core.AbstractClassGenerator.create(AbstractClassGenerator.java:216)
at net.sf.cglib.core.KeyFactory$Generator.create(KeyFactory.java:145)
at net.sf.cglib.core.KeyFactory.create(KeyFactory.java:117)
at net.sf.cglib.core.KeyFactory.create(KeyFactory.java:108)
at net.sf.cglib.core.KeyFactory.create(KeyFactory.java:104)
at net.sf.cglib.proxy.Enhancer.<clinit>(Enhancer.java:69)
... 54 more
2007-10-7 10:44:42 org.apache.catalina.core.StandardContext start
严重: Error listenerStart
2007-10-7 10:44:42 org.apache.catalina.core.StandardContext start
严重: Context [/d1] startup failed due to previous errors
2007-10-7 10:44:42 org.apache.catalina.core.ApplicationContext log
信息: Closing Spring root WebApplicationContext
2007-10-7 10:44:42 org.apache.catalina.loader.WebappClassLoader loadClass
信息: Illegal access: this web application instance has been stopped already. Could not load java.net.BindException. The eventual following stack trace is caused by an error thrown for debugging purposes as well as to attempt to terminate the thread which caused the illegal access, and has no functional impact.
java.lang.IllegalStateException
at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1244)
at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1204)
at java.lang.ClassLoader.loadClassInternal(Unknown Source)
at com.mysql.jdbc.CommunicationsException.<init>(CommunicationsException.java:155)
at com.mysql.jdbc.MysqlIO.send(MysqlIO.java:2652)
at com.mysql.jdbc.MysqlIO.quit(MysqlIO.java:1345)
at com.mysql.jdbc.Connection.realClose(Connection.java:4731)
at com.mysql.jdbc.Connection.cleanup(Connection.java:2034)
at com.mysql.jdbc.Connection.finalize(Connection.java:3244)
at java.lang.ref.Finalizer.invokeFinalizeMethod(Native Method)
at java.lang.ref.Finalizer.runFinalizer(Unknown Source)
at java.lang.ref.Finalizer.access$100(Unknown Source)
at java.lang.ref.Finalizer$FinalizerThread.run(Unknown Source)
2007-10-7 10:44:42 org.apache.catalina.loader.WebappClassLoader loadClass
信息: Illegal access: this web application instance has been stopped already. Could not load com.mysql.jdbc.Messages. The eventual following stack trace is caused by an error thrown for debugging purposes as well as to attempt to terminate the thread which caused the illegal access, and has no functional impact.
java.lang.IllegalStateException
at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1244)
at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1204)
at java.lang.ClassLoader.loadClassInternal(Unknown Source)
at com.mysql.jdbc.CommunicationsException.<init>(CommunicationsException.java:174)
at com.mysql.jdbc.MysqlIO.send(MysqlIO.java:2652)
at com.mysql.jdbc.MysqlIO.quit(MysqlIO.java:1345)
at com.mysql.jdbc.Connection.realClose(Connection.java:4731)
at com.mysql.jdbc.Connection.cleanup(Connection.java:2034)
at com.mysql.jdbc.Connection.finalize(Connection.java:3244)
at java.lang.ref.Finalizer.invokeFinalizeMethod(Native Method)
at java.lang.ref.Finalizer.runFinalizer(Unknown Source)
at java.lang.ref.Finalizer.access$100(Unknown Source)
at java.lang.ref.Finalizer$FinalizerThread.run(Unknown Source) 



BeanSoft 2007-08-27 13:41 发表评论
]]>转载: Spring 入门实战http://www.blogjava.net/beansoft/archive/2007/08/25/139232.htmlBeanSoftBeanSoftSat, 25 Aug 2007 03:05:00 GMThttp://www.blogjava.net/beansoft/archive/2007/08/25/139232.htmlhttp://www.blogjava.net/beansoft/comments/139232.htmlhttp://www.blogjava.net/beansoft/archive/2007/08/25/139232.html#Feedback2http://www.blogjava.net/beansoft/comments/commentRss/139232.htmlhttp://www.blogjava.net/beansoft/services/trackbacks/139232.html创] Spring 入门实战
2007-07-20 17:50
一、创建项目
    创建名为“SpringHelloworld”的Web Project，如下图：

二、加入Spring支持  
    点击菜单“MyEclipse” -- “Add Spring Capabities"启动向导，在项目中加入对Spring的支持。
    第一步：如下图：


    第二步：如下图：

三、增加Java包
    在src下面创建三个Java包，分别名为：com.pqf.beans, com.pqf.impl, com.pqf.test。 如下图：

四、编写名为HelloWorld的JavaBean
    在com.pqf.beans 包下面创建 java 类，名为HelloWorld，其源代码如下：
        public class HelloWorld {
        public String msg=null;

        public String getMsg() {
          return msg;
        }

        public void setMsg(String msg) {
          this.msg = msg;
        }
        }
五、编写不使用Spring的测试程序
    在 com.pqf.test 包下面创建测试程序，名为：TestHelloWorldNoSpring, 源代码如下：
    package com.pqf.test;
    import com.pqf.beans.HelloWorld;
    public class TestHelloWorldNoSpring {
    public static void main(String[] args) {
        HelloWorld hw=new HelloWorld();
        hw.setMsg("向全世界问好!");
        System.out.println(hw.getMsg());
    }
    }
    运行这个测试程序，应该在控制台输出：向全世界问好!

六、设置Spring配置文件
    双击打开 applicationContext.xml 文件，这个文件是Spring的核心配置文件。
    编辑修改文件内容如下:
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
    <bean id="HelloWorld" class="com.pqf.beans.HelloWorld">
        <property name="msg">
            <value>愿世界和平，向全世界问好！</value>
        </property>
    </bean>
</beans>

    其中，<bean> 描述将类 com.pqf.beans.HelloWorld 以 HelloWorld 为标识，注入到其他程序中；
    <property> 描述将属性 msg 的值注入到程序中。

 六、编写使用Spring的测试程序
    在com.pqf.test包下面创建使用Spring技术的测试程序，源代码如下：

    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.FileSystemXmlApplicationContext;
    import com.pqf.beans.HelloWorld;