BlogJava-老妖的博客-随笔分类-spring

关于 sitemesh 在weblogic spring下的乱码问题解决

老妖 — Sun, 18 Dec 2005 04:39:00 GMT

web.xml

xml version="1.0" encoding="UTF-8"?>
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>

    <filter>
        <filter-name>sitemeshfilter-name>
        <filter-class>com.opensymphony.module.sitemesh.filter.PageFilterfilter-class>
    filter>

    <filter-mapping>
        <filter-name>sitemeshfilter-name>
        <url-pattern>/*url-pattern>
    filter-mapping>
<filter>
  <filter-name>encodingFilterfilter-name>
  <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
  <init-param>
   <param-name>encodingparam-name>
   <param-value>UTF-8param-value>
  init-param>
  <init-param>
   <param-name>forceEncodingparam-name>
   <param-value>trueparam-value>
  init-param>
filter>
  <filter-mapping>
  <filter-name>encodingFilterfilter-name>
  <url-pattern>*.jspurl-pattern>
filter-mapping>
web-app>

sitemesh.xml:

xml version="1.0" encoding="utf-8"?>
<sitemesh>
    <property name="decorators-file" value="/WEB-INF/decorators.xml"/>
    <excludes file="${decorators-file}"/>
    <page-parsers>
        <parser default="true" class="com.opensymphony.module.sitemesh.parser.HTMLPageParser"/>
        <parser content-type="text/html" class=" com.opensymphony.module.sitemesh.parser.HTMLPageParser"/>
        <parser content-type="text/html;charset=UTF-8" class="com.opensymphony.module.sitemesh.parser.HTMLPageParser"/>
    page-parsers>

    <decorator-mappers>
        <mapper class="com.opensymphony.module.sitemesh.mapper.ConfigDecoratorMapper">
            <param name="config" value="${decorators-file}"/>
        mapper>
    decorator-mappers>
sitemesh>

decorators.xml:

xml version="1.0" encoding="utf-8"?>

<decorators defaultdir="/decorators">
    <decorator name="main" page="test.jsp">
        <pattern>/*pattern>
    decorator>

    <decorator name="panel" page="panel.jsp"/>
    <decorator name="printable" page="printable.jsp"/>
decorators>

decorator的页面test.jsp：

<%@ page contentType="text/html; charset=utf-8"%>
<%@ taglib uri=" http://www.opensymphony.com/sitemesh/decorator" prefix="decorator" %>
<%@ taglib uri=" http://www.opensymphony.com/sitemesh/page" prefix="page" %>
DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" " http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml ">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
<title><decorator:title default="Mysterious page" />title>
<decorator:head />
head>

<body>
<table width="100%" height="100%" border="0">
  <tr>
    <td width="29%">td>
    <td width="71%"> 哈哈哈哈
     td>
  tr>
  <tr>
    <td><decorator:body />td>
    <td> td>
  tr>
table>
body>
html>

被装饰器页面1.jsp:

<%@ page contentType="text/html;charset=utf-8"%>
<html>
    <head>
    <meta http-equiv="Content-Type" content="text/html;charset=utf-8">
    <title>哈哈title>
    head>
    <body>
        <h2>哈哈h2>
    body>
html>

作业环境：

weblogic sp 5

spring 1.2.6

sitemesh 2.2.1
发现有中文乱码问题。

在google上查找很久都没有方法解决，后怀疑是处理编码的org.springframework.web.filter.CharacterEncodingFilter中的代码中只对request做了编码处理而没有对response做编码处理
自己对其做了一点小的修改红色字部分

protected void doFilterInternal(
            HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)
            throws ServletException, IOException {
        super.doFilter(request,response,filterChain);

        if (this.forceEncoding || request.getCharacterEncoding() == null) {
            request.setCharacterEncoding(this.encoding);
            response.setContentType("text/html; charset="+this.encoding);
        }
        filterChain.doFilter(request, response);
    }

解决乱码问题

老妖 2005-12-18 12:39 发表评论

新发现spring论坛的一个FAQ整理连接

老妖 — Wed, 23 Nov 2005 06:26:00 GMT

http://forum.springframework.org/archive/index.php/

老妖 2005-11-23 14:26 发表评论

acegi扩展AbstractFilterInvocationDefinitionSource

老妖 — Sun, 13 Nov 2005 17:58:00 GMT

1 package com.rdk.security.intercept.web;
2
3 import net.sf.acegisecurity.intercept.web.FilterInvocationDefinitionSource;
4 import net.sf.acegisecurity.intercept.web.AbstractFilterInvocationDefinitionSource;
5 import net.sf.acegisecurity.ConfigAttributeDefinition;
6 import net.sf.acegisecurity.SecurityConfig;
7
8 import java.util.Iterator;
9
10 import com.rdk.security.persistence.ActionDao;
11 import com.rdk.security.domain.Action;
12 import com.rdk.security.domain.RoleAction;
13 import com.rdk.core.NullParameterException;
14 import org.springframework.dao.IncorrectResultSizeDataAccessException;
15
16 /**
17 * Clase encargada de implementar la propiedad ObjectDefinitionSource para la clase de acegi
18 * FilterSecurityInterceptor esta implementacion le entrega el objeto ConfigAttributeDefinition
19 * con los roles permitidos a acceder a la url pasada como parametro.
20 * User: Rodney Gallart (rodney@radikalsystems.com)
21 * Date: Jan 25, 2005
22 * Time: 4:20:04 PM
23 */
24 public class DaoBasedFilterInvocationDefinitionSource
25 extends AbstractFilterInvocationDefinitionSource
26 implements FilterInvocationDefinitionSource {
27
28 private ActionDao actionDao;
29 /**
30 * Implementacion dao de los objetos de tipo Action
31 * @param actionDao
32 */
33 public void setActionDao(ActionDao actionDao) {
34 this.actionDao = actionDao;
35 }
36
37 /**
38 * A este metodo se le pasa como parametro la url que se quiere acceder y devuelve el objeto
39 * ConfigAttributeDefinition donde vienen los roles que pueden acceder a esa url
40 *
41 * ConfigifAttributeDefinition contiene una lista de objetos que implementan la interfaz ConfigAttribute
42 * puede ser SecurityConfig (Roles como String)
43 *
44 * Ahora con la url pasada como parametro debe hacerse una busqueda en una lista de acciones cuando se encuentre
45 * la accion a la cual pertenece la url entonces se devuelve la lista de Roles
46 * TODO Analizar la posibilidad de implementar un mecanismo de cache Mapa(url, Action) y bajo que condiciones vaciarlo
47 * @param url Pasada como paremetro para buscar sus roles permitidos
48 * @return ConfigAttributeDefinition
49 */
50 public ConfigAttributeDefinition lookupAttributes(String url) {
51 if (url == null)
52 throw new NullParameterException("Parametro url null");
53 try {
54 url = url.toLowerCase();
55 url = url.substring(1);
56 if (url.contains("&"))
57 url = url.substring(0, url.indexOf("&"));
58 Action act = actionDao.findByUrl(url);
59 return obtainRolesInConfigAttributeDefinitionObject(act);
60 }
61 catch (IncorrectResultSizeDataAccessException ex) {
62 return null;
63 }
64 }
65
66 /**
67 * En este metodo se van a obtener los roles asociados a la accion y se va a crear el
68 * objeto de tipo ConfigAttributeDefinition con la lista de objetos SecurityConfig
69 * @param act
70 * @return
71 */
72 private ConfigAttributeDefinition obtainRolesInConfigAttributeDefinitionObject(Action act) {
73 ConfigAttributeDefinition cad = new ConfigAttributeDefinition();
74 Iterator it = act.getRoles().iterator();
75 while(it.hasNext()) {
76 RoleAction ra = (RoleAction) it.next();
77 SecurityConfig sc = new SecurityConfig(ra.getRole().getName());
78 cad.addConfigAttribute(sc);
79 }
80 return cad;
81 }
82
83 public Iterator getConfigAttributeDefinitions() {
84 return null;
85 }
86
87 }
88

老妖 2005-11-14 01:58 发表评论

spring的mail如何发送html格式的邮件--转自邢红瑞的blog

老妖 — Fri, 11 Nov 2005 18:36:00 GMT

发送html格式邮件很简单,下面给出个例子
先是一个抽象的基类

1 package com.educast.mail;
2
3 import org.springframework.mail.javamail.JavaMailSender;
4
5 /**
6  * @author  mfc42d
7  *
8  */
9 public abstract class BaseMailSender {
10
11  protected String to;
12  protected String from;
13  protected String subject;
14  protected JavaMailSender sender;
15
16
17  public void setTo(String to) {
18   this.to = to;
19  }
20
21  public void setFrom(String from) {
22   this.from = from;
23  }
24
25  public void setSubject(String subject) {
26   this.subject = subject;
27  }
28
29  public void setJavaMailSender(JavaMailSender sender) {
30   this.sender = sender;
31  }
32 }
33
34 下面是具体的实现类
35 package com.educast.mail;
36
37
38 import javax.mail.MessagingException;
39 import javax.mail.internet.MimeMessage;
40
41 import org.springframework.context.ApplicationContext;
42 import org.springframework.context.support.FileSystemXmlApplicationContext;
43 import org.springframework.mail.javamail.MimeMessageHelper;
44
45 /**
46  * @author mfc42d
47  *
48  */
49 public class SimpleHtmlMailSender extends BaseMailSender {
50
51  public void sendMessage() throws MessagingException {
52   MimeMessage msg = sender.createMimeMessage();
53   MimeMessageHelper helper = new MimeMessageHelper(msg, true, "GB2312");
54
55   helper.setTo(to);
56   helper.setFrom(from);
57   helper.setSubject(subject);
58   helper.setText("

"Content-Type" content="text/html; charset=gb2312">

郁闷!"
59 + "

", true);
60
61   sender.send(msg);
62  }
63
64  public static void main(String[] args) throws Exception {
65   ApplicationContext ctx = new FileSystemXmlApplicationContext(
66     new String[] { "D:\\WORK\\JDBC\\mail\\src\\MailSender.xml" });
67
68   SimpleHtmlMailSender sender = (SimpleHtmlMailSender) ctx
69     .getBean("messageSender");
70   sender.sendMessage();
71  }
72 }
73
74

最后是spring配置文件

1 DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
2 <beans>
3  <bean id="sender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
4   <property name="host">
5    <value>mail.mymail.cnvalue>
6   property>
7   <property name="username">
8    <value>webmastervalue>
9   property>
10   <property name="password">
11    <value>passwordvalue>
12   property>
13         <property name="javaMailProperties">
14         <props>
15         <prop key="mail.smtp.auth">trueprop>
16         props>
17         property>
18
19     bean>
20
21  <bean id="messageSender" class="com.educast.mail.SimpleHtmlMailSender">
22   <property name="javaMailSender">
23    <ref bean="sender"/>
24   property>
25   <property name="to">
26    <value>mfc42d@163.comvalue>
27   property>
28   <property name="from">
29    <value>webmaster@mymail.cnvalue>
30   property>
31   <property name="subject">
32    <value>testvalue>
33   property>
34  bean>
35 beans>
36 使用esmtp认证必须添加红色部分
37

老妖 2005-11-12 02:36 发表评论

using Spring Hotswapping for loading user classes from DB

老妖 — Wed, 09 Nov 2005 08:50:00 GMT

Everyone using spring is aware of the easy to handle ApplicationContext of Spring. There you define all your beans inside an XML and you can use them as AOP targets or plain javabeans. But what if you have AOP targets that are not known on Spring startup because they reside in a DB or some other storage. IMO there are two ways you can go:

Code something like a PropertyPlaceHolderConfigurer but acting on a Database, resulting in a DBPropertyPlaceholderConfigurer. The problem with this approach is that you dont have any datasource definitions at this point and it will be tricky to get it work this way.
The other approach is using a HotSwappableTargetSource as target of your ProxyFactoryBean. Here you simply code a DummyImplementation of the desired interface and replace the dummy on startup with the real implementation from the database or from whereever you want via reflection.

I decide to use the HotSwappable direction to achieve the overall goal.
example ApplicationContext definition

1 <bean id="erpDataCollectorTarget" class="de.logentis.DummyERPDataCollector">
2    <property name="clientManagerService" ref="clientManagerService"/>
3    <property name="erpDataSource" ref="erpDataSource"/>
4  bean>
5 <bean id="swapper" class="org.springframework.aop.target.HotSwappableTargetSource">
6    <constructor-arg ref="erpDataCollectorTarget"/>
7 bean><bean id="erpDataCollector" class="org.springframework.aop.framework.ProxyFactoryBean">
8     <property name="targetSource" ref="swapper"/>
9     <property name="proxyInterfaces" value="de.logentis.ERPDataCollector"/>
10     <property name="interceptorNames">
11       <list>
12          <value>jdoTransactionInterceptorvalue>
13       list>
14     property>
15 bean>

Look at the erpDataCollector bean, its a transactional proxy in my scenario. But as you can see, i dont use the "target" attribute with a concrete and not changeable bean definition but a "targetSource" pointing to a HotSwappableTargetSource. This hotswappable things get a default implementation which is nothing more than an empty implementation of the ERPDataCollector interface.

Now when my application starts up, the internal spring plumbing comes first, after that i have a section where i setup my application with various defaults and other stuff. Somewhere in that section, i am doing this:

1 // get the swapper bean from the Context, not shown here
2 HotSwappableTargetSource swapper = getFromContext();
3 // get the user defined class name from DB
4 String classToLoad = getClassNameFromDB();
5 Object o = getInstanceFromClassName(classToLoad);// swap the instances, removes the dummy and put the real impl
6 // oldObject is the dummy and will be returned, normally you dont need
7 // it anymore, but you can printout to be sure that it works like exptected
8 Object oldObject = swapper.swap(o);

At this point, the dummy is replaced with the class from the DB. Of course the DB holds only the full name of the class and it will get loaded via reflection. I left that out because this is plain java programming. Retrieving the swapper from the applicationContext is also trivial. One way would be to put this very code inside a bean which is controlled by Spring, this way you can just define a setter for the swapper and add the needed XML definition for that bean. If you run this from a ServletContextListener (best way to place bootstrap code), you can use something like this.
do Hotswapping in ServletContextListener

1 public class ApplicationInitFilter implements ServletContextListener {    public void contextInitialized(ServletContextEvent event) {
2         WebApplicationContext webAppContext =
3                WebApplicationContextUtils.getWebApplicationContext(
4                                     event.getServletContext());        HotSwappableTargetSource swapper =
5                (HotSwappableTargetSource)webAppContext.getBean("swapper");        String classToLoad = getClassNameFromDB();
6         Object o = getInstanceFromClassName(classToLoad);
7         Object oldObject = swapper.swap(o);
8     }    public void contextDestroyed(ServletContextEvent event) {
9       // empty impl
10     }}

The interessting thing is, you can program an admin frontend for defining classes like this (its a german screenshot, but it should be readable for everyone): http://www.logemann.org/divs/dynclassdef.gif

All in all, you can see that i used the HotSwappableTargetSource in a slightly different way than its used to be. I think the inventors created this class mainly to switch from one "real" implementation to another. In our context, we are switching from a dummy implementation to the real one but technically its the same of course. Thanks to Daniel Potter from the Spring community for mentioning the HotSwappable class, this really speeded up in finding my overall solution.

老妖 2005-11-09 16:50 发表评论

使用spring的mail发送带有图片的html的邮件--转自邢红瑞的blog

老妖 — Thu, 03 Nov 2005 11:41:00 GMT

1 package com.educast.mail;
2
3 import org.springframework.mail.javamail.MimeMessageHelper;
4 import org.springframework.context.ApplicationContext;
5 import org.springframework.context.support.FileSystemXmlApplicationContext;
6 import org.springframework.core.io.FileSystemResource;
7
8 import javax.mail.internet.MimeMessage;
9 import javax.mail.MessagingException;
10 import java.io.File;
11
12 public class ImageMailSender extends BaseMailSender {
13         public void sendMessage() throws MessagingException {
14         MimeMessage msg = sender.createMimeMessage();
15         MimeMessageHelper helper = new MimeMessageHelper(msg, true, "GB2312");
16
17         helper.setTo(to);
18         helper.setFrom(from);
19         helper.setSubject(subject);
20
21         helper.setText("

"Content-Type\" content=\"text/html; charset=gb2312\">

郁闷!"
22                 + ""cid:img\">", true);
23
24         // add the image
25         FileSystemResource image = new FileSystemResource(new File(
26                 "c:\\0.gif"));
27         helper.addInline("img", image);
28
29         sender.send(msg);
30     }
31
32     public static void main(String[] args) throws Exception {
33        ApplicationContext ctx = new FileSystemXmlApplicationContext(
34     new String[] { "D:\\WORK\\JDBC\\mail\\src\\javaMailSender.xml" });
35         ImageMailSender sender = (ImageMailSender) ctx.getBean("messageSender");
36         sender.sendMessage();
37     }
38 }
39
40

1 DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
2 <beans>
3  <bean id="sender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
4   <property name="host">
5    <value>localhostvalue>
6   property>
7   <property name="username">
8    <value>webmastervalue>
9   property>
10   <property name="password">
11    <value>passwordvalue>
12   property>
13         <property name="javaMailProperties">
14         <props>
15         <prop key="mail.smtp.auth">trueprop>
16         props>
17         property>
18
19     bean>
20
21  <bean id="messageSender" class="com.educast.mail.ImageMailSender">
22   <property name="javaMailSender">
23    <ref bean="sender"/>
24   property>
25   <property name="to">
26    <value>mfc42d@163.comvalue>
27   property>
28   <property name="from">
29    <value>webmaster@mymail.cnvalue>
30   property>
31   <property name="subject">
32    <value>HTML Mailvalue>
33   property>
34  bean>
35 beans>
36
37

老妖 2005-11-03 19:41 发表评论

使用spring的mail发送带有附件的html的邮件--摘自邢红瑞的blog

老妖 — Thu, 03 Nov 2005 11:39:00 GMT

有的朋友问我如何发送带有附件的html的邮件,不要加入contentID,使用addAttachment即可
实现代码

1 package com.educast.mail;
2
3 import org.springframework.mail.javamail.MimeMessageHelper;
4 import org.springframework.core.io.FileSystemResource;
5 import org.springframework.context.ApplicationContext;
6 import org.springframework.context.support.FileSystemXmlApplicationContext;
7
8 import javax.mail.MessagingException;
9 import javax.mail.internet.MimeMessage;
10 import java.io.File;
11
12
13 public class AttachmentMailSender extends BaseMailSender  {
14    public void sendMessage() throws MessagingException {
15         MimeMessage msg = sender.createMimeMessage();
16         MimeMessageHelper helper = new MimeMessageHelper(msg, true, "GB2312");
17
18         helper.setTo(to);
19         helper.setFrom(from);
20         helper.setSubject(subject);
21
22         helper.setText("

"Content-Type\" content=\"text/html; charset=gb2312\">

郁闷!"
23                 + "", true);
24
25
26 // add the rar file
27        FileSystemResource rarfile = new FileSystemResource(new File(
28                "c:\\a.rar"));
29        helper.addAttachment("a.rar", rarfile);
30
31
32         sender.send(msg);
33     }
34
35     public static void main(String[] args) throws Exception {
36           ApplicationContext ctx = new FileSystemXmlApplicationContext(
37                 new String[] { "D:\\WORK\\JDBC\\mail\\src\\javaMailSender.xml" });
38         AttachmentMailSender sender = (AttachmentMailSender) ctx.getBean("messageSender");
39         sender.sendMessage();
40     }
41 }
42
43

配置文件

1 DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
2 <beans>
3  <bean id="sender" class="org.springframework.mail.javamail.JavaMailSenderImpl">
4   <property name="host">
5    <value>localhostvalue>
6   property>
7   <property name="username">
8    <value>webmastervalue>
9   property>
10   <property name="password">
11    <value>passwordvalue>
12   property>
13         <property name="javaMailProperties">
14         <props>
15         <prop key="mail.smtp.auth">trueprop>
16         props>
17         property>
18
19     bean>
20
21  <bean id="messageSender" class="com.educast.mail.AttachmentMailSender">
22   <property name="javaMailSender">
23    <ref bean="sender"/>
24   property>
25   <property name="to">
26    <value>mfc42d@sohu.comvalue>
27   property>
28   <property name="from">
29    <value>webmaster@mymail.cnvalue>
30   property>
31   <property name="subject">
32    <value>HTML Mailvalue>
33   property>
34  bean>
35 beans>
36
37

老妖 2005-11-03 19:39 发表评论

使用Spring邮件发送Email

老妖 — Sat, 29 Oct 2005 12:58:00 GMT

Spring提供了一个发送电子邮件的高级抽象层，它向用户屏蔽了底层邮件系统的一些细节，同时负责低层次的代表客户端的资源处理。Spring邮件抽象层的主要包为org.springframework.mail。它包括了发送电子邮件的主要接口MailSender和封装了简单邮件的属性如from, to,cc, subject, text的值对象叫做SimpleMailMessage。
首先:我们定义一个发送邮件的接口:IMailManager.java
/*
* IMailManager.java
* Copyright 2005, All rights reserved.
*/
package test.mail.manager;

import test.common.logic.IManager;
import test.model.Order;

/**
* Note:this interface mainly deal with the sendOrder
*/
public interface IMailManager extends IManager{

void sendOrder(Order order);
}

然后实现这个接口:MailManager.java
/*
* MailManager.java
* Copyright 2005, All rights reserved.
*/
package test.mail.manager;

import org.springframework.mail.MailException;
import org.springframework.mail.MailSender;
import org.springframework.mail.SimpleMailMessage;

import test.common.logic.impl.Manager;
import test.model.Order;

/**
* Note:the implements of IMailManager
*/
public class MailManager extends Manager implements IMailManager {

private MailSender mailSender;
private SimpleMailMessage message;

public void sendOrder(Order order) {
SimpleMailMessage mailMessage = new SimpleMailMessage(this.message);
mailMessage.setTo(order.getUser().getEmail());
mailMessage.setText("Dear"
+ order.getUser().getFirstName()
+ order.getUser().getLastName()
+ ", thank you for placing order. Your order code is "
+ order.getCode());
try{
mailSender.send(mailMessage);
}catch(MailException ex) {
System.err.println(ex.getMessage());
}

}

/**
* @param mailSender The mailSender to set.
*/
public void setMailSender(MailSender mailSender) {
this.mailSender = mailSender;
}
/**
* @param message The message to set.
*/
public void setMessage(SimpleMailMessage message) {
this.message = message;
}
}

然后我们在Action 里面调用: SendMailAction.java
/*
* SendMail.java
* Copyright 2005, All rights reserved.
*/
package test.mail.action;

import test.common.action.BaseAction;
import test.mail.manager.IMailManager;
import test.order.dao.IOrderDao;
import test.model.Order;

/**
* Note: SendMailAction
*/
public class SendMailAction extends BaseAction {
private IMailManager mailManager;
private IOrderDao orderDao;
private long orderId;

public String execute() throws Exception {
Order order = orderDao.getOrder(orderId);
mailManager.sendOrder(order);
return SUCCESS;
}

/**
* @return Returns the mailManager.
*/
public IMailManager getMailManager() {
return mailManager;
}
/**
* @param mailManager The mailManager to set.
*/
public void setMailManager(IMailManager mailManager) {
this.mailManager = mailManager;
}

/**
* @return Returns the orderDao.
*/
public IOrderDao getOrderDao() {
return orderDao;
}
/**
* @param orderDao The orderDao to set.
*/
public void setOrderDao(IOrderDao orderDao) {
this.orderDao = orderDao;
}
/**
* @return Returns the orderId.
*/
public long getOrderId() {
return orderId;
}
/**
* @param orderId The orderId to set.
*/
public void setOrderId(long orderId) {
this.orderId = orderId;
}
}

最后的就是配置了.在ApplicationContext.xml文件里加上如下的内容:

smtp服务器
用户名
密码
/**如果服务器要求验证,加上此**/

true
25000

class="org.springframework.mail.SimpleMailMessage">

你的电子邮件地址

邮件标题

在对应的action配置文件中加入:
class=" test.mail.action.SendMailAction" singleton="false" >

在xwork配置文件中:

success.ftl
error.ftl

老妖 2005-10-29 20:58 发表评论

Acegi简介

老妖 — Sat, 29 Oct 2005 12:46:00 GMT

Acegi安全系统，是一个用于Spring Framework的安全框架，能够和目前流行的Web容器无缝集成。它使用了Spring的方式提供了安全和认证安全服务，包括使用Bean Context，拦截器和面向接口的编程方式。因此，Acegi安全系统能够轻松地适用于复杂的安全需求。
安全涉及到两个不同的概念，认证和授权。前者是关于确认用户是否确实是他们所宣称的身份。授权则是关于确认用户是否有允许执行一个特定的操作。
在Acegi安全系统中，需要被认证的用户，系统或代理称为"Principal"。Acegi安全系统和其他的安全系统不同，它并没有角色和用户组的概念。
Acegi系统设计
关键组件
Acegi安全系统包含以下七个关键的功能组件：
l Authentication对象，包含了Principal，Credential和Principal的授权信息。同时还可以包含关于发起认证请求的客户的其他信息，如IP地址。
2 ContextHolder对象，使用ThreadLocal储存Authentication对象的地方。
3 AuthenticationManager，用于认证ContextHolder中的Authentication对象。
4 AccessDecissionManager，用于授权一个特定的操作。
5 RunAsManager，当执行特定的操作时，用于选择性地替换Authentication对象。
6 Secure Object拦截器，用于协调AuthenticationManager，AccessDecissionManager，RunAsManager和特定操作的执行。
7 ObjectDefinitionSource，包含了特定操作的授权定义。
这七个关键的功能组件的关系如下图所示（图中灰色部分是关键组件）：

安全管理对象
Acegi安全系统目前支持两类安全管理对象。
第一类的安全管理对象管理AOP Alliance的MethodInvocation，开发人员可以用它来保护Spring容器中的业务对象。为了使Spring管理的Bean可以作为 MethodInvocation来使用，Bean可以通过ProxyFactoryBean和BeanNameAutoProxyCreator来管理，就像在Spring的事务管理一样使用。
第二类是FilterInvocation。它用过滤器（Filter）来创建，并简单地包装了HTTP的ServletRequest， ServletResponse和FilterChain。FilterInvocation可以用来保护HTTP资源。通常，开发人员并不需要了解它的工作机制，因为他们只需要将Filter加入web.xml，Acegi安全系统就可以工作了。
安全配置参数
每个安全管理对象都可以描述数量不限的各种安全认证请求。例如，MethodInvocation对象可以描述带有任意参数的任意方法的调用，而FilterInvocation可以描述任意的HTTP URL。
Acegi安全系统需要记录应用于每个认证请求的安全配置参数。例如，对于BankManager.getBalance（int accountNumber）方法和BankManager.approveLoan（int applicationNumber）方法，它们需要的认证请求的安全配置很不相同。
为了保存不同的认证请求的安全配置，需要使用配置参数。从实现的视角来看，配置参数使用ConfigAttribute接口来表示。Acegi安全系统提供了ConfigAttribute接口的一个实现，SecurityConfig，它把配置参数保存为一个字符串。
ConfigAttributeDefinition类是ConfigAttribute对象的一个简单的容器，它保存了和特定请求相关的ConfigAttribute的集合。
当安全拦截器收到一个安全认证请求时，需要决定应用哪一个配置参数。换句话说，它需要找出应用于这个请求的 ConfigAttributeDefinition对象。这个查找的过程是由ObjectDefinitionSource接口来处理的。这个接口的主要方法是public ConfigAttributeDefinition getAttributes(Object object)，其中Object参数是一个安全管理对象。因为安全管理对象包含有认证请求的详细信息，所以 ObjectDefinitionSource接口的实现类可以从中获得所需的详细信息，以查找相关的ConfigAttributeDefiniton 对象。
Acegi如何工作
为了说明Acegi安全系统如何工作，我们设想一个使用Acegi的例子。通常，一个安全系统需要发挥作用，它必须完成以下的工作：
l 首先，系统从客户端请求中获得Principal和Credential；
2 然后系统认证Principal和Credential信息；
3 如果认证通过，系统取出Principal的授权信息；
4 接下来，客户端发起操作请求；
5 系统根据预先配置的参数检查Principal对于该操作的授权；
6 如果授权检查通过则执行操作，否则拒绝。
那么，Acegi安全系统是如何完成这些工作的呢？首先，我们来看看Acegi安全系统的认证和授权的相关类图：

图中绿色部分是安全拦截器的抽象基类，它包含有两个管理类，AuthenticationManager和AccessDecisionManager，如图中灰色部分。AuthenticationManager用于认证ContextHolder中的Authentication对象（包含了 Principal，Credential和Principal的授权信息）；AccessDecissionManager则用于授权一个特定的操作。
下面来看一个MethodSecurityInterceptor的例子：
class="net.sf.acegisecurity.intercept.method.MethodSecurityInterceptor">

true

net.sf.acegisecurity.context.BankManager.delete*=
ROLE_SUPERVISOR,RUN_AS_SERVER
net.sf.acegisecurity.context.BankManager.getBalance=
ROLE_TELLER,ROLE_SUPERVISOR,BANKSECURITY_CUSTOMER,RUN_

上面的配置文件中，MethodSecurityInterceptor是AbstractSecurityInterceptor的一个实现类。它包含了两个管理器，authenticationManager和accessDecisionManager。这两者的配置如下：

class="net.sf.acegisecurity.providers.dao.DaoAuthenticationProvider">

false

准备工作做好了，现在我们来看看Acegi安全系统是如何实现认证和授权机制的。以使用HTTP BASIC认证的应用为例子，它包括下面的步骤：
1. 用户登录系统，Acegi从acegisecurity.ui子系统的安全拦截器（如BasicProcessingFilter）中得到用户的登录信息（包括Principal和Credential）并放入Authentication对象，并保存在ContextHolder对象中；
2. 安全拦截器将Authentication对象交给AuthenticationManager进行身份认证，如果认证通过，返回带有Principal 授权信息的Authentication对象。此时ContextHolder对象的Authentication对象已拥有Principal的详细信息；
3. 用户登录成功后，继续进行业务操作；
4. 安全拦截器（bankManagerSecurity）收到客户端操作请求后，将操作请求的数据包装成安全管理对象（FilterInvocation或MethodInvocation对象）；
5. 然后，从配置文件（ObjectDefinitionSource）中读出相关的安全配置参数ConfigAttributeDefinition；
6. 接着，安全拦截器取出ContextHolder中的Authentication对象，把它传递给AuthenticationManager进行身份认证，并用返回值更新ContextHolder的Authentication对象；
7. 将Authentication对象，ConfigAttributeDefinition对象和安全管理对象（secure Object）交给AccessDecisionManager，检查Principal的操作授权；
8. 如果授权检查通过则执行客户端请求的操作，否则拒绝；
AccessDecisionVoter
注意上节的accessDecisionManager是一个AffirmativeBased类，它对于用户授权的投票策略是，只要通过其中的一个授权投票检查，即可通过；它的allowIfAllAbstainDecisions属性值是false，意思是如果所有的授权投票是都是弃权，则通不过授权检查。
Acegi安全系统包括了几个基于投票策略的AccessDecisionManager，上节的RoleVoter就是其中的一个投票策略实现，它是 AccessDecisionVoter的一个子类。AccessDecisionVoter的具体实现类通过投票来进行授权决策， AccessDecisionManager则根据投票结果来决定是通过授权检查，还是抛出AccessDeniedException例外。
AccessDecisionVoter接口共有三个方法：
public int vote(Authentication authentication, Object object, ConfigAttributeDefinition config);
public boolean supports(ConfigAttribute attribute);
public boolean supports(Class clazz);
其中的vote方法返回int返回值，它们是AccessDecisionVoter的三个静态成员属性：ACCESS_ABSTAIN,，ACCESS_DENIED和ACCESS_GRANTED，它们分别是弃权，否决和赞成。
Acegi安全系统中，使用投票策略的AccessDecisionManager共有三个具体实现类：AffirmativeBased、 ConsensusBased和UnanimousBased。它们的投票策略是，AffirmativeBased类只需有一个投票赞成即可通过； ConsensusBased类需要大多数投票赞成即可通过；而UnanimousBased类需要所有的投票赞成才能通过。
RoleVoter类是一个Acegi安全系统AccessDecisionVoter接口的实现。如果ConfigAttribute以ROLE_开头，RoleVoter则进行投票。如果GrantedAuthority的getAutority方法的String返回值匹配一个或多个以ROLE_ 开头的ConfigAttribute，则投票通过，否则不通过。如果没有以ROLE_开头的ConfigAttribute，RoleVoter则弃权。
安全拦截器
拦截器如何工作
MethodInvocation拦截器
FilterInvocation拦截器
认证
认证请求
认证管理器
Authentication Provider
授权
Access Decision Manager
Voting Decision Manager
授权管理推荐
ContextHolder的用户接口
用户接口目标
HTTP会话认证
HTTP Basic认证
1、Log4j的概念
Log4j中有三个主要的组件，它们分别是Logger、Appender和Layout，Log4j 允许开发人员定义多个Logger，每个Logger拥有自己的名字，Logger之间通过名字来表明隶属关系。有一个Logger称为Root，它永远存在，且不能通过名字检索或引用，可以通过Logger.getRootLogger()方法获得，其它Logger通过 Logger.getLogger(String name)方法。
Appender则是用来指明将所有的log信息存放到什么地方，Log4j中支持多种appender，如 console、files、GUI components、NT Event Loggers等，一个Logger可以拥有多个Appender，也就是你既可以将Log信息输出到屏幕，同时存储到一个文件中。
Layout的作用是控制Log信息的输出方式，也就是格式化输出的信息。
Log4j中将要输出的Log信息定义了5种级别，依次为DEBUG、INFO、WARN、ERROR和FATAL，当输出时，只有级别高过配置中规定的级别的信息才能真正的输出，这样就很方便的来配置不同情况下要输出的内容，而不需要更改代码，这点实在是方便啊。

2、Log4j的配置文件
虽然可以不用配置文件，而在程序中实现配置，但这种方法在如今的系统开发中显然是不可取的，能采用配置文件的地方一定一定要用配置文件。Log4j支持两种格式的配置文件：XML格式和Java的property格式，本人更喜欢后者，首先看一个简单的例子吧，如下：

log4j.rootLogger=debug, stdout, R
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

# Pattern to output the caller's file name and line number.
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) - %m%n

log4j.appender.R=org.apache.log4j.RollingFileAppender
log4j.appender.R.File=example.log
log4j.appender.R.MaxFileSize=100KB

# Keep one backup file
log4j.appender.R.MaxBackupIndex=1

log4j.appender.R.layout=org.apache.log4j.PatternLayout
log4j.appender.R.layout.ConversionPattern=%p %t %c - %m%n

首先，是设置root，格式为 log4j.rootLogger=[level],appenderName, ...，其中level就是设置需要输出信息的级别，后面是appender的输出的目的地，appenderName就是指定日志信息输出到哪个地方。您可以同时指定多个输出目的地。配置日志信息输出目的地Appender，其语法为
log4j.appender.appenderName = fully.qualified.name.of.appender.class
log4j.appender.appenderName.option1 = value1
...
log4j.appender.appenderName.option = valueN
Log4j提供的appender有以下几种：
org.apache.log4j.ConsoleAppender（控制台）
org.apache.log4j.FileAppender（文件）
org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件）
org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生新文件）
org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）
配置日志信息的格式（布局），其语法为：
log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class
log4j.appender.appenderName.layout.option1 = value1
....
log4j.appender.appenderName.layout.option = valueN
Log4j提供的layout有以下几种：
org.apache.log4j.HTMLLayout（以HTML表格形式布局），
org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

3、Log4j在程序中的使用
要在自己的类中使用Log4j，首先声明一个静态变量Logger logger=Logger.getLog("classname")；在使用之前，用PropertyConfigurator.configure ("配置文件")配置一下，现在就可以使用了，用法如下：logger.debug("debug message")或者logger.info("info message")，看下面一个小例子：

import com.foo.Bar;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
public class MyApp {
static Logger logger = Logger.getLogger(MyApp.class.getName());
public static void main(String[] args) {
// BasicConfigurator replaced with PropertyConfigurator.
PropertyConfigurator.configure(args[0]);
logger.info("Entering application.");
Bar bar = new Bar();
bar.doIt();
logger.info("Exiting application.");
}
}
[简介]
对于一个典型的Web应用，完善的认证和授权机制是必不可少的，在SpringFramework中，Juergen Hoeller提供的范例JPetStore给了一些这方面的介绍，但还远远不够，Acegi是一个专门为SpringFramework提供安全机制的项目，全称为Acegi Security System for Spring，当前版本为0.5.1，就其目前提供的功能，应该可以满足绝大多数应用的需求。

本文的主要目的是希望能够说明如何在基于Spring构架的Web应用中使用Acegi，而不是详细介绍其中的每个接口、每个类。注意，即使对已经存在的Spring应用，通过下面介绍的步骤，也可以马上享受到Acegi提供的认证和授权。

[基础工作]
在你的Web应用的lib中添加Acegi下载包中的acegi-security.jar

[web.xml]
实现认证和授权的最常用的方法是通过filter，Acegi亦是如此，通常Acegi需要在web.xml添加以下5个filter:

Acegi Channel Processing Filter

net.sf.acegisecurity.util.FilterToBeanProxy

targetClass

net.sf.acegisecurity.securechannel.ChannelProcessingFilter

Acegi Authentication Processing Filter

net.sf.acegisecurity.util.FilterToBeanProxy

targetClass

net.sf.acegisecurity.ui.webapp.AuthenticationProcessingFilter

Acegi HTTP BASIC Authorization Filter

net.sf.acegisecurity.util.FilterToBeanProxy

targetClass

net.sf.acegisecurity.ui.basicauth.BasicProcessingFilter

Acegi Security System for Spring Auto Integration Filter

net.sf.acegisecurity.ui.AutoIntegrationFilter

Acegi HTTP Request Security Filter

net.sf.acegisecurity.util.FilterToBeanProxy

targetClass

net.sf.acegisecurity.intercept.web.SecurityEnforcementFilter

最先引起迷惑的是net.sf.acegisecurity.util.FilterToBeanProxy，Acegi自己的文档上解释是： “What FilterToBeanProxy does is delegate the Filter's methods through to a bean which is obtained from the
Spring application context. This enables the bean to benefit from the Spring application context lifecycle support and configuration flexibility.”，如希望深究的话，去看看源代码应该不难理解。

再下来就是添加filter-mapping了：

Acegi Channel Processing Filter

Acegi Authentication Processing Filter

Acegi HTTP BASIC Authorization Filter

Acegi Security System for Spring Auto Integration Filter

Acegi HTTP Request Security Filter

这里，需要注意以下两点：
1) 这几个filter的顺序是不能更改的，顺序不对将无法正常工作；
2) 如果你的应用不需要安全传输，如https，则将"Acegi Channel Processing Filter"相关内容注释掉即可；
3) 如果你的应用不需要Spring提供的远程访问机制，如Hessian and Burlap，将"Acegi HTTP BASIC Authorization
Filter"相关内容注释掉即可。

[applicationContext.xml]
接下来就是要添加applicationContext.xml中的内容了，从刚才FilterToBeanFactory的解释可以看出，真正的filter都
在Spring的applicationContext中管理：

1) 首先，你的数据库中必须具有保存用户名和密码的table，Acegi要求table的schema必须如下：

CREATE TABLE users (
username VARCHAR(50) NOT NULL PRIMARY KEY,
password VARCHAR(50) NOT NULL,
enabled BIT NOT NULL
);
CREATE TABLE authorities (
username VARCHAR(50) NOT NULL,
authority VARCHAR(50) NOT NULL
);
CREATE UNIQUE INDEX ix_auth_username ON authorities ( username, authority );
ALTER TABLE authorities ADD CONSTRAINT fk_authorities_users foreign key (username) REFERENCES users
(username);

2) 添加访问你的数据库的datasource和Acegi的jdbcDao，如下：

${jdbc.driverClassName}
${jdbc.url}
${jdbc.username}
${jdbc.password}

3) 添加DaoAuthenticationProvider:

5

如果你需要对密码加密，则在daoAuthenticationProvider中加入：bean="passwordEncoder"/>，Acegi提供了几种加密方法，详细情况可看包
net.sf.acegisecurity.providers.encoding

4) 添加authenticationManager:

5) 添加accessDecisionManager:

false

6) 添加authenticationProcessingFilterEntryPoint:

class="net.sf.acegisecurity.ui.webapp.AuthenticationProcessingFilterEntryPoint">
/acegilogin.jsp
false

其中acegilogin.jsp是登陆页面，一个最简单的登录页面如下：

<%@ taglib prefix='c' uri='http://java.sun.com/jstl/core' %>
<%@ page import="net.sf.acegisecurity.ui.AbstractProcessingFilter" %>
<%@ page import="net.sf.acegisecurity.AuthenticationException" %>

Login

Login

7) 添加filterInvocationInterceptor:

class="net.sf.acegisecurity.intercept.web.FilterSecurityInterceptor">

CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
\A/sec/administrator.*\Z=ROLE_SUPERVISOR
\A/sec/user.*\Z=ROLE_TELLER

这里请注意，要objectDefinitionSource中定义哪些页面需要权限访问，需要根据自己的应用需求进行修改，我上面给出
的定义的意思是这样的：
a. CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON意思是在比较请求路径时全部转换为小写
b. \A/sec/administrator.*\Z=ROLE_SUPERVISOR意思是只有权限为ROLE_SUPERVISOR才能访问/sec/administrator*的页面
c. \A/sec/user.*\Z=ROLE_TELLER意思是只有权限为ROLE_TELLER的用户才能访问/sec/user*的页面

添加securityEnforcementFilter:

9) 添加authenticationProcessingFilter:

class="net.sf.acegisecurity.ui.webapp.AuthenticationProcessingFilter">

/loginerror.jsp

/

/j_acegi_security_check

其中authenticationFailureUrl是认证失败的页面。

10) 如果需要一些页面通过安全通道的话，添加下面的配置:

CONVERT_URL_TO_LOWERCASE_BEFORE_COMPARISON
\A/sec/administrator.*\Z=REQUIRES_SECURE_CHANNEL
\A/acegilogin.jsp.*\Z=REQUIRES_SECURE_CHANNEL
\A/j_acegi_security_check.*\Z=REQUIRES_SECURE_CHANNEL
\A.*\Z=REQUIRES_INSECURE_CHANNEL

[缺少了什么？]
Acegi目前提供了两种"secure object"，分别对页面和方法进行安全认证管理，我这里介绍的只是利用
FilterSecurityInterceptor对访问页面的权限控制，除此之外，Acegi还提供了另外一个Interceptor——
MethodSecurityInterceptor，它结合runAsManager可实现对对象中的方法的权限控制，使用方法可参看Acegi自带的文档
和contact范例。

[最后要说的]
本来以为只是说明如何使用Acegi而已，应该非常简单，但真正写起来才发现想要条理清楚的理顺所有需要的bean还是很
困难的，但愿我没有遗漏太多东西，如果我的文章有什么遗漏或错误的话，还请参看Acegi自带的quick-start范例，但请
注意，这个范例是不能直接拿来用的。
分析和学习Spring中的jpetstore用户管理
存在用户的系统，必然需要用户的登录和认证，今天就通过分析Spring中自带的jpetstore的例子来学习一下如何实现在Spring构架的系统中用户登录。
1、首先从注册用户开始，先看看jpetstore-servlet.xml中关于注册用户的bean定义，从定义命名中就可以看出下面这段就是注册用户的：

index

1). formView呢？从AccountFormController的构造函数中得到，原来为EditAccountForm；
2). EditoAccountForm.jsp中显得非常乱，其实没有多少难理解的地方，最主要的是这个form既是添加新用户的，又是编辑用户信息的，所以显得有点乱糟糟的。
2、添加好了新用户，接下来看看如何登录，在jpetstore-servlet中发现这两个相关bean定义，如下：

SignonForm

1). 第二个bean是在运行时用户输入用户名和密码的form，叫做SignonForm，对于这个 ParameterizableViewController，用文档里的话说这是最简单的Controller，其作用就是在运行中指向 Controller而不是直接指向jsp文件，仅此而已。
2). SignonForm.jsp，里面就是一个简单的form，其action就是第一个bean，即/shop/signon.do，最需要注意的是 signonForwardAction，其主要作用是forward到需要输入用户名和密码的那个页面上去，这个变量哪里来的呢？看看下面：

原来，上面的signonInterceptor实现了preHandle，因此在请求上面的map页面时，首先要经过这个Interceptor，看看 SignonInterceptor的源码，原来在其中为signon.jsp赋予一个signonForwardAction对象，呵呵，总算明白了。
3). 接下来去学习一下SignonController，其主体部分中可以看出，首先取出用户输入的username和password，然后到数据库中验证有没有这个用户，如果没有这个用户，返回各错误页面；如果成功，首先生成一个UserSession对象，在request的session加入这个 userSession，注意这部分代码中给出了PagedListHolder分页的简单使用方法，关于分页显示，以后再学习吧。
3、登录成功后，就可以根据不同的用户设施不同的行为了，取得用户信息，无非就是从session取出userSession即可。

老妖 2005-10-29 20:46 发表评论

acegi 拾遗

老妖 — Mon, 17 Oct 2005 06:35:00 GMT

   protected ConfigAttributeDefinition lookupAttributes(MethodInvocation mi) {
      //construct secureObjectName
      String secureObjectName=mi.getMethod().getDeclaringClass().getName() +"."+ mi.getMethod().getName();
      SecureObject secureObject=securityManager.getSecureObject(secureObjectName);
      if(secureObject==null)//if secure object not exist in database
         return null;
      //retrieving roles associated with this secure object
      List secureObjectRoles=(List)securityManager.getSecureObjectRoles(secureObject);
      //creating ConfigAttributeDefinition
      if(!secureObjectRoles.isEmpty()){
         ConfigAttributeEditor configAttrEditor=new ConfigAttributeEditor();
         StringBuffer rolesStr=new StringBuffer();
         for(int i=0;i            SecureObjectRole sor=(SecureObjectRole)secureObjectRoles.get(i);
            rolesStr.append(sor.getRole().getRoleName()).append(",");
         }
         configAttrEditor.setAsText( rolesStr.toString().substring(0,rolesStr.length()-1) );
         ConfigAttributeDefinition configAttrDef=(ConfigAttributeDefinition)configAttrEditor.getValue();
         return configAttrDef;
      }
      return null;

   }

老妖 2005-10-17 14:35 发表评论

acegi怎么去动态的实现role和privilege?

老妖 — Wed, 28 Sep 2005 14:32:00 GMT

查阅了很多帖子都没有点思路

老妖 2005-09-28 22:32 发表评论

User:
Password:

BlogJava-老妖的博客-随笔分类-spring

关于 sitemesh 在weblogic spring下的乱码问题解决

新发现spring论坛的一个FAQ整理连接

acegi扩展AbstractFilterInvocationDefinitionSource

spring的mail如何发送html格式的邮件--转自邢红瑞的blog

郁闷!"59 + "

using Spring Hotswapping for loading user classes from DB

使用spring的mail发送带有图片的html的邮件--转自邢红瑞的blog

使用spring的mail发送带有附件的html的邮件--摘自邢红瑞的blog

使用Spring邮件发送Email

Acegi简介

Login

acegi 拾遗

acegi怎么去动态的实现role和privilege?

郁闷!"
59 + "