亚洲av无码日韩av无码网站冲,国产精品亚洲一区二区三区在线,亚洲人成色777777老人头

java世界畅谈 — Wed, 19 Oct 2005 15:47:00 GMT

　　�q�些天在�l�看《J2EE Development without EJB》书�Q�感受颇多。说��h��做J2EE斚w��开发也有几�q�_��自己认�ؓ自己�q�是有一定实力的。但是看完以后，再针�Ҏ��们项目的开发感觉很多地方做的确实有很多问题。因��Z��直都�q�样做，没有人提出异议。闷着头做事情�Q�有时候确实不好，要交��，特别是要們֐�那些�l�验丰富的前辈的教诲�?BR>　　OO�Q�接触开发也�q�么多年了，��实很少有项目，真正做到OO的。看看我们的��目�Q�POJO做成伪对象，只是负责了值的传递，只有可怜的setter和getter�Q�其中没有�Q何业务逻辑操作的代码（没有��M��行�ؓ�Q�。我们所谓的业务逻辑是引入一个Manager�q�行�l�合处理�?BR>　　�Q�年前，也是看了jPetStore收益很多。今天再�ơ看�q�个代码。又引发了更多的思考�?BR>　　先看jPetstore的处理：
　　在org.springframework.sample.jpetstore包中�Q?BR>　　Account�c�：比较��单，普通的JavaBean�?BR>　　Cart�c�d��CarItem�c�：从关�p�L��型中�Q�可以看到这是一个主从关�pȝ��对象。其中Cart�Q�购物�R�Q�中有不��行为。例如：新增、删除购物�R��目�Q�计��总金额。一般来��_��我们��目中一般这��L��逻辑是写在Manager�c�M��的�?BR>　　在Order�c�M��Q�也采用一些业务行为，例如初始化订单等�{��?BR>　　

java世界畅谈 2005-10-19 23:47 发表评论

java世界畅谈 — Mon, 25 Jul 2005 03:32:00 GMT

Sending Email with Spring mail abstraction layer
使用Spring邮�g抽象层发送邮�Ӟ��
18.1. Introduction
介绍
Spring provides a higher level of abstraction for sending electronic mail which shields the user from the specifics of underlying mailing system and is responsible for a low level resource handling on behalf of the client.

Spring 支持一个更高层的抽象用来发送电子邮�Ӟ��它隐藏底层邮件系�l�的�l�节�q�且代表客户端对低��别的控制 �?/P>

18.2. Spring mail abstraction structure
Spring邮�g抽象�l�构
The main package of Spring mail abstraction layer is org.springframework.mail package. It contains central interface for sending emails called MailSender and the value object which encapsulates properties of a simple mail such as from, to, cc, subject, text called SimpleMailMessage. This package also contains a hierarchy of checked exceptions which provide a higher level of abstraction over the lower level mail system exceptions with the root exception being MailException.Please refer to JavaDocs for more information on mail exception hierarchy.

Sring邮�g抽象层的主要包是�Q�org.springframework.mail 包。它包含叫MailSender为发送邮件的核心接口和包含简单邮件属性例如from,to,cc,subject,text叫SimpleMailMessage的值对�? �q�个包也包含一个检查异常的层次�Q�它支持一个更高��别的抽象��过低��别的邮�g�pȝ��异常伴随根异常存在MailException. 请参考JavaDocs为更多的信息杂邮件异常层�ơ�?/P>

Spring also provides a sub-interface of MailSender for specialized JavaMail features such as MIME messages, namely org.springframework.mail.javamail.JavaMailSender It also provides a callback interface for preparation of JavaMail MIME messages, namely org.springframework.mail.javamail.MimeMessagePreparator

Spring也支持一个MailSender的专用于JavaMail特征例如MIME消息子接口，命名为org.springframework.javamail.JavaMailerSener。它也支持一个�ؓJavaMail MIME信息的准备回调接口，命名为org.springframework.mail.JavaMail.MimeMessagePreparator.

MailSender:

public interface MailSender {

    /**
     * Send the given simple mail message.
     * @param simpleMessage message to send
     * @throws MailException in case of message, authentication, or send errors
     * 发送给定的��单邮件信�?BR>     * @参数 simpleMessage 发送的信息
     * @throws MailException 假设信息�Q�证明或发送错�?BR>     */

    public void send(SimpleMailMessage simpleMessage) throws MailException;

    /**
     * Send the given array of simple mail messages in batch.
     * @param simpleMessages messages to send
     * @throws MailException in case of message, authentication, or send errors
     */
    public void send(SimpleMailMessage[] simpleMessages) throws MailException;

}

JavaMailSender:

public interface JavaMailSender extends MailSender {

    /**
     * Create a new JavaMail MimeMessage for the underlying JavaMail Session
     * of this sender. Needs to be called to create MimeMessage instances
     * that can be prepared by the client and passed to send(MimeMessage).
     * @return the new MimeMessage instance
     * @see #send(MimeMessage)
     * @see #send(MimeMessage[])
     * 创徏一个新的JavaMail MimeMessage 为潜在的JavaMail的发送者的会话.
     * 需要被调用来创建MimeMessage实例�Q�它可以被客户准备�ƈ且被传递发�?MimeMessage).
     * @return �q�个新的MimeMessage 实例
     * @see #send(Message)
     * @sess #send(MimeMessage[])
     */
    public MimeMessage createMimeMessage();

    /**
     * Send the given JavaMail MIME message.
     * The message needs to have been created with createMimeMessage.
     * @param mimeMessage message to send
     * @throws MailException in case of message, authentication, or send errors
     * @see #createMimeMessage
     */
    public void send(MimeMessage mimeMessage) throws MailException;

    /**
     * Send the given array of JavaMail MIME messages in batch.
     * The messages need to have been created with createMimeMessage.
     * @param mimeMessages messages to send
     * @throws MailException in case of message, authentication, or send errors
     * @see #createMimeMessage
     */
    public void send(MimeMessage[] mimeMessages) throws MailException;

    /**
     * Send the JavaMail MIME message prepared by the given MimeMessagePreparator.
     * Alternative way to prepare MimeMessage instances, instead of createMimeMessage
     * and send(MimeMessage) calls. Takes care of proper exception conversion.
     * @param mimeMessagePreparator the preparator to use
     * @throws MailException in case of message, authentication, or send errors
     */
    public void send(MimeMessagePreparator mimeMessagePreparator) throws MailException;

    /**
     * Send the JavaMail MIME messages prepared by the given MimeMessagePreparators.
     * Alternative way to prepare MimeMessage instances, instead of createMimeMessage
     * and send(MimeMessage[]) calls. Takes care of proper exception conversion.
     * @param mimeMessagePreparators the preparator to use
     * @throws MailException in case of message, authentication, or send errors
     */
    public void send(MimeMessagePreparator[] mimeMessagePreparators) throws MailException;

}
MimeMessagePreparator:

public interface MimeMessagePreparator {

    /**
     * Prepare the given new MimeMessage instance.
     * @param mimeMessage the message to prepare
     * @throws MessagingException passing any exceptions thrown by MimeMessage
     * methods through for automatic conversion to the MailException hierarchy
     */
    void prepare(MimeMessage mimeMessage) throws MessagingException;

}

18.3. Using Spring mail abstraction
使用Spring邮�g抽象
Let's assume there is a business interface called OrderManager
让我们假定这里有一个商业接口叫OrderManager

public interface OrderManager {

void placeOrder(Order order);

}

and there is a use case that says that an email message with order number would need to be generated and sent to a customer placing that order. So for this purpose we want to use MailSender and SimpleMailMessage
�q�且�q�里有一个有用案例，可以说一个伴随订单编��L��邮�g信息��需要被产生�q�且发送给一个客户处理这个订单。所以�ؓ�q�个目的我们惌��使用MailSender和SimpleMailSender.

Please note that as usual, we work with interfaces in the business code and let Spring IoC container take care of wiring of all the collaborators for us.

��h��意照常，我们工作使用在商业代码中的接口�ƈ且让Spring Ioc 容器兛_��为我们的所有合作者�?/P>

Here is the implementation of OrderManager
�q�里是OrderManager的实�?

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

public class OrderManagerImpl implements OrderManager {

private MailSender mailSender;
private SimpleMailMessage message;

    public void setMailSender(MailSender mailSender) {
        this.mailSender = mailSender;
    }

    public void setMessage(SimpleMailMessage message) {
        this.message = message;
    }

public void placeOrder(Order order) {

//... * Do the business calculations....
//... * Call the collaborators to persist the order

        //Create a thread safe "sandbox" of the message
        SimpleMailMessage msg = new SimpleMailMessage(this.message);
        msg.setTo(order.getCustomer().getEmailAddress());
        msg.setText(
            "Dear "
                + order.getCustomer().getFirstName()
                + order.getCustomer().getLastName()
                + ", thank you for placing order. Your order number is "
                + order.getOrderNumber());
        try{
            mailSender.send(msg);
        }
        catch(MailException ex) {
            //log it and go on
            System.err.println(ex.getMessage());
        }
    }
}
Here is what the bean definitions for the code above would look like:
�q�里是这个�ؓ�q�个以上代码bean定义�c�M��Q?/P>

class="org.springframework.mail.javamail.JavaMailSenderImpl">
mail.mycompany.com

      class="org.springframework.mail.SimpleMailMessage">
    customerservice@mycompany.com
    Your order

      class="com.mycompany.businessapp.support.OrderManagerImpl">



Here is the implementation of OrderManager using MimeMessagePreparator callback interface. Please note that the mailSender property is of type JavaMailSender in this case in order to be able to use JavaMail MimeMessage:

import javax.mail.Message;
import javax.mail.MessagingException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;

import javax.mail.internet.MimeMessage;
import org.springframework.mail.MailException;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.MimeMessagePreparator;

public class OrderManagerImpl implements OrderManager {
    private JavaMailSender mailSender;

    public void setMailSender(JavaMailSender mailSender) {
        this.mailSender = mailSender;
    }

public void placeOrder(final Order order) {

        //... * Do the business calculations....
        //... * Call the collaborators to persist the order


        MimeMessagePreparator preparator = new MimeMessagePreparator() {
            public void prepare(MimeMessage mimeMessage) throws MessagingException {
                mimeMessage.setRecipient(Message.RecipientType.TO,
                        new InternetAddress(order.getCustomer().getEmailAddress()));
                mimeMessage.setFrom(new InternetAddress("mail@mycompany.com"));
                mimeMessage.setText(
                    "Dear "
                        + order.getCustomer().getFirstName()
                        + order.getCustomer().getLastName()
                        + ", thank you for placing order. Your order number is "
                        + order.getOrderNumber());
            }
        };
        try{
            mailSender.send(preparator);
        }
        catch(MailException ex) {
            //log it and go on
            System.err.println(ex.getMessage());
        }
    }
}
If you want to use JavaMail MimeMessage to the full power, the MimeMessagePreparator is available at your fingertips.
如果你想使用JavaMail MimeMessage来��得��够强大，MimeMessagePreparator 是可以利用的�?/P>

Please note that the mail code is a crosscutting�Q�横切的�Q?concern�Q�关注） and is a perfect candidate�Q�候选） for refactoring into a custom Spring AOP advice, which then could easily be applied to OrderManager target. Please see the AOP chapter.

18.3.1. Pluggable MailSender implementations
Spring comes with two MailSender implementations out of the box - the JavaMail implementation and the implementation on top of Jason Hunter's MailMessage class that's included in http://servlets.com/cos (com.oreilly.servlet). Please refer to JavaDocs for more information.

18.4. Using the JavaMail MimeMessageHelper
One of the components that comes in pretty handy when dealing with JavaMail messages is the org.springframework.mail.javamail.MimeMessageHelper. It prevents you from having to use the nasty APIs the the javax.mail.internet classes. A couple of possible scenarios:

18.4.1. Creating a simple MimeMessage and sending it
Using the MimeMessageHelper it's pretty easy to setup and send a MimeMessage:

// of course you would setup the mail sender using
// DI in any real-world cases
JavaMailSenderImpl sender = new JavaMailSenderImpl();
sender.setHost("mail.host.com");

MimeMessage message = sender.createMimeMesage();
MimeMessageHelper helper = new MimeMessageHelper(message);
helper.setTo("test@host.com");
helper.setText("Thank you for ordering!");

sender.send(message);

18.4.2. Sending attachments and inline resources
Email allow for attachments, but also for inline resources in multipart messages. Inline resources could for example be images or stylesheet you want to use in your message, but don't want displayed as attachment. The following shows you how to use the MimeMessageHelper to send an email along with an inline image.

JavaMailSenderImpl sender = new JavaMailSenderImpl();
sender.setHost("mail.host.com");

MimeMessage message = sender.createMimeMesage();

// use the true flag to indicate you need a multipart message
MimeMessageHelper helper = new MimeMessageHelper(message, true);
helper.setTo("test@host.com");

// use the true flag to indicate the text included is HTML
helper.setText(
""
true);

// let's include the infamous windows Sample file (this time copied to c:/)
FileSystemResource res = new FileSystemResource(new File("c:/Sample.jpg"));
helper.addInline("identifier1234", res);

// if you would need to include the file as an attachment, use
// addAttachment() methods on the MimeMessageHelper

sender.send(message);

Inline resources are added to the mime message using the Content-ID specified as you've seen just now (identifier1234 in this case). The order in which you're adding the text and the resource are VERY important. First add the text and after that the resources. If you're doing it the other way around, it won't work!

java世界畅谈 2005-07-25 11:32 发表评论

使用MethodInvokingJobDetailFactoryBean

java世界畅谈 — Fri, 22 Jul 2005 03:23:00 GMT

Using the MethodInvokingJobDetailFactoryBean
使用MethodInvokingJobDetailFactoryBean
Often you just need to invoke a method on a specific object. Using the MethodInvokingJobDetailFactoryBean you can do exactly this:
�l�常圎ͼ�你仅仅需要调用一个对象的一个方法。��用MethodInvokingJobDetailFactoryBean,你可以正��地�q�样做：

class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">

doIt

The above example will result in the doIt being called on the exampleBusinessObject (see below):

public class BusinessObject {

// properties and collaborators

public void doIt() {
// do the actual work
}
}

Using the MethodInvokingJobDetailFactoryBean you don't need to create one-line jobs that just invoke a method, and you only need to create the actual business object and wire up the detail object.
使用MethodInvokingJobDetailFactoryBean 你不需要创��Z��个在�U�的jobs�Q�仅仅调用它的方法，你可以仅仅只需要创��Z��个实际的逻辑对象�q�且把它�l�定到细节对象�?/P>

By default, Quartz Jobs are stateless, resulting in the possibility of jobs interfering with each other. If you specify two triggers for the same JobDetail, it might be possible that before the first job has finished, the second one will start. If JobDetail objects implement the Stateful interface, this won't happen. The second job will not start before the first one has finished. To make jobs resulting from the MethodInvokingJobDetailFactoryBean non-concurrent, set the concurrent flag to false.

�~�省圎ͼ�Quartz jobs是无状态的�Q�在jobs的可能性作为结果媄响彼此。如果你限定两个触发器�ؓ同一个JohDetail,它在�W�一个job已经完成时是可能的，�W�二个将会开始。如果JobDetail实现了状态接口，它将不会发生�?BR> class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">

    doIt
    false


Note: By default, jobs will run in a concurrent fashion.

java世界畅谈 2005-07-22 11:23 发表评论

Spring--��单��用quartz实现定时作业

java世界畅谈 — Wed, 20 Jul 2005 13:37:00 GMT

定时批处理作业是J2EE企业应用里很重要的一环，用来在晚间进行胦务挂账，数据转存�Q�新闻联播等�{�操作�?

而在Spring里，已经很好的集成了Quartz�Q�简单到像配cron一��P��在xml文�g里面配一下时间就可以自动执行�Q�不需要写一行代码。Spring对Quartz大刀阔斧的简化堪�U�范例，Quartz��目�l�也许可以学习一下�?/P>

            class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        
        confirmOrder


    
        
            
        
        
            0 0 6,12,20 * * ?

上面�q�段配置文�g规定了在早上6点和晚上8�Ҏ��行financeDAO对象的confirmOrder()�Ҏ��.

附：cronExpression配置说明

字段	允许�?/TH>	允许的特�D�字�W?/TH>
`�U?/CODE>`	`0-59`	`, - * /`
`�?/CODE>`	`0-59`	`, - * /`
`��时`	`0-23`	`, - * /`
`日期`	`1-31`	`, - * ? / L W C`
`月䆾`	`1-12 或�?JAN-DEC`	`, - * /`
`星期`	`1-7 或�?SUN-SAT`	`, - * ? / L C #`
`�q�_��可选）`	`留空, 1970-2099`	`, - * /`

java世界畅谈 2005-07-20 21:37 发表评论

TriggerListeners and JobListeners

java世界畅谈 — Wed, 20 Jul 2005 13:27:00 GMT

TriggerListeners and JobListeners
Listeners are objects that you create to perform actions based on events occuring within the scheduler. As you can probably guess, TriggerListeners receive events related to trigger,and JobListners receive events related to jobs.

Trigger-related events include: trigger firings,trigger mis-firings(discussed in the "Triggers" sections of this document),and trigger completions (the jobs fired off by the trigger is finished).

To create a listener,simply create an object the implements either the org.quartz.TriggerListener and/or org.quartz.JobListener interface. Listeners are then registered with the scheduler during run time ,and must be given a name(or rather ,they must advertise their own name via their getName()method. Listeners can be registered as either "global" or "non-global". Global listeners receive events for ALL triggers/jobs, and non-global listeners receive events only for the specific triggers/jobs that explicitely name the listener in their getTriggerListenerNames() or getJobListenerNames() properties.

scheduler.addGlobalJobListener(myJobListener);
or
scheudler.addJobListener(myJobListener);

Listeners are not used by most users of Quartz,but are handy when application requirements create the need for the notification of events,without the Job itself explicitly nofifying the application.

java世界畅谈 2005-07-20 21:27 发表评论

What is Quartz? (什么是Quartz?)

java世界畅谈 — Wed, 20 Jul 2005 04:05:00 GMT

What is Quartz? (什么是Quartz?)
Quartz is a full-featured, open source job scheduling system that can be integrated with, or used along side virtually any J2EE or J2SE application - from the smallest stand-alone application to the largest e-commerce system. Quartz can be used to create simple or complex schedules for executing tens, hundreds, or even tens-of-thousands of jobs; jobs whose tasks are defined as standard Java components or EJBs. The Quartz Scheduler includes many enterprise-class features, such as JTA transactions and clustering.

Quartz 是一个功能齐全的、开源的job旉��调度�pȝ��Q�它可以被结合的,或者伴随虚拟的��M��J2EE或J2SE�E�序-从最��的独立的应用程序到最大的e-commerce�pȝ��被��用。Quartz可以用来创徏��单或复杂的时间调度来执行十、百、千、甚至上万的jobs;获得的job被定义�ؓ一个标准的java�l��g或EJBs. �q�个Quartz 旉��调度包含很多企业�cȝ��特征�Q�例如JTA事务和簇�?/P>

The licensing of Quartz versions 1.0 through 1.4.5 is similar to both the BSD and ASF (Apache) public licenses, which means it's free for use, even within commercial products.

Quartz 1.0版本�?.4.5版本的licensing 是类��g��BSD和ASF(apache)公共licenses, 它意味着可以免费使用�Q�甚至��用在商业产品中��用�?BR>With the upcoming release of version 1.5.0, Quartz is moving to the Apache 2.0 license.
伴随1.5.0版本的发布，Quartz��{�U�d��apache 2.0 的license.

What can Quartz do for you? (Quartz可以��Z��做什么？)
If your application has tasks that need to occur at given moments in time, or if your system has recurring maintenance jobs then Quartz may be your ideal solution.

如果你的�E�序有一些这��L��d��Q�它需要及时地发生在给定时��_��或者你如果你的�pȝ��有连�l�维护jobs�Q�那么Quartz可以成�ؓ你的理想的解��x��案�?/P>

Sample uses of job scheduling with Quartz:
Quartz使用job旉��调度的范�?/P>

Driving Workflow: As a new order is initially placed, schedule a Job to fire in exactly 2 hours, that will check the status of that order, and trigger a warning notification if an order confirmation message has not yet been received for the order, as well as changing the order's status to 'awaiting intervention'.
System Maintenance: Schedule a job to dump the contents of a database into an XML file every business day (all weekdays except holidays) at 11:30 PM.

工作��驱动：作�ؓ一个新的订单被初始化放�|�，调度一个job��d��作在正好两个��时内，它将��查订单的状态，�q�且触发一个警告通知如果订单��认信息没有被接�Ӟ��又改变订单的状态到"�{�待�q�涉"�?BR>�pȝ��l�护�Q�调度一个job来将数据库�{化�ؓXML文�g 每商业日期（所有周末除了节假日�Q�在下午11�Q?0�?/P>

java世界畅谈 2005-07-20 12:05 发表评论

Using the ProxyFactoryBean to create AOP proxies

java世界畅谈 — Thu, 07 Jul 2005 02:43:00 GMT

Using the ProxyFactoryBean to create AOP proxies
If you're using the Spring Ioc container (an applicationContext or BeanFactory) for you business object--and you should be!-- you will want to use one of Spring's AOP fatoryBeans.(Remeber that a factory bean introduces a layer of indirection, enabling it to create objects of different type).

The basic way to create an AOP proxy in Spring to use the org.springframework.aop.framework.ProxyFactoryBean. This gives complete control over the pointcuts an advice that will apply, and theire ordering . However ,there are simpler options that are preferable(更可取的、更好的) if you don't need such control.

Basics
The proxyFactoryBean,like other Spring FactoryBean implementations,introduces a level of indirection(间接). If you define a ProxyFactoryBean with name foo,what objects referencing foo see is not the ProxyFactoryBean instance itself, but an object created by the ProxyFactoryBeans's implementation of the getObject() method. This method will create an AOP proxy wrapping a target object.

One of the most important benefits of using a ProxyFactoryBean or other IoC-aware to create AOP proxies, it that it means that advices and pointcuts can also be managed by IoC. This is a powerful feature , enabling certain approaches that are hard to achieve with other AOP frameworks. For example,an advice may itself reference application objects(besides the target , which should be available in any AOP framework),benefiting from all the pluggability provided by Dependency Injection.

JavaBean properties
Like most FactoryBean implementations provided with Spring, ProxyfactoryBean is itself a JavaBean. It properties are used to:
Specify the target you want to proxy
Specify whether to use CGLIB

Some key properties are inherited from org.springframework.aop.framework.ProxyConfig: the subclass for all AOP proxy factories. These include:
proxyTargetClass: true if we should proxy the target class,rather than its interfaces. If this is true we need to use CGLIB.

optimize: whether to apply aggressive optimization to created proxies. Don't use this setting unless you understand how the relevant(相关�? AOP proxy handles optimization. This is currently used only for CGLIB proxies;it has no effect with JDK dynamic proxies(the default).

frozen:whether avice changes should be disallowed once the proxy factory has bean configured. Default is false.

exposeProxy: whether the current proxy should be exposed in a ThreadLocal so that it can be accessed by the target (It's available via the MethodInvocation without the need for a ThreadLocal) If a target needs to obtain the proxy and exposedProxy is true, the target can use the AopContext.currentProxy() method.

aopProxyFactory: the implementation of AopProxyFactory to use. Offers a way of customizing whether to use dynammic proxies,CGLIB or any other proxy strategy. The default implementation will choose dynamic proxies or CGLIB appropriately. There should be need to use this property, it's intended to allow the addition of new proxy types in spring 1.1.

Other properties specific to ProxyFactoryBean include:
.proxyInterfaces: array of String interface names. If this isn't supplied, a CGLIB proxy for the target class will be used.
.interceptorNames:String array of Advisor,interceptor or other advice names to apply.Ordering is sugnicicant. first come,first serve that is. The first interceptor in the list will be the first to be able to interceptor the invocation (of course if it concerns a regular MethodInterceptor or BeforeAdvice. The names are bean names in the current factory , including bean names from ancestor factories. You can't mention bean references here since doing so would result iin the ProxyFactoryBean ignoring the singleton setting of the advise. you can append an iinterceptor name with an asterisk(*). This will result in the application of all advisor beans withe names starting with the part before the asterisk to be applied. An example of using this feature can be found below.

Singleton: whether or not the factory should return a single object, no matter how often the getObject() method is called. Server FactoryBean implementations offer such a method. Default value is true. If you want to use stateful advice --for example ,for stateful mixins-user prototype advices along withe s singleton value of false.

Proxying interfaces

Tony
51

Custom string property value

   com.company.Person




         myAdvisor
         debugInterceptor

java世界畅谈 2005-07-07 10:43 发表评论

Spring中的 JasperReports

java世界畅谈 — Wed, 29 Jun 2005 02:24:00 GMT

13.7. JasperReports
JasperReports (http://jasperreports.sourceforge.net) is a powerful, open-source reporting engine that supports the creation of report designs using an easily understood XML file formats. JasperReports is capable of rendering reports output into four different formats: CSV, Excel, HTML and PDF.

13.7.1. Dependencies �Q�依赖）
Your application will need to include the latest release of JasperReports, which at the time of writing was 0.6.1. JasperReports itself depends on the following projects:

BeanShell

Commons BeanUtils

Commons Collections

Commons Digester

Commons Logging

iText

POI

JasperReports also requires a JAXP compliant(适应�? XML parser.

13.7.2. Configuration�Q�配�|�）
To configure JasperReports views in your ApplicationContext you have to define a ViewResolver to map view names to the appropriate view class depending on which format you want your report rendered in.

13.7.2.1. Configuring the ViewResolver
Typically, you will use the ResourceBundleViewResolver to map view names to view classes and files in a properties file

        views



Here we've configured an instance of ResourceBundleViewResolver which will look for view mappings in the resource bundle with base name views. The exact contents of this file is described in the next section.

13.7.2.2. Configuring the Views
Spring contains five different View implementations for JasperReports four of which corresponds to one of the four output formats supported by JasperReports and one that allows for the format to be determined at runtime:

JasperReport View Class
1.JasperReportsView           CSV
2.JasperReportsHtmlView       HTML
3.JasperReportsPdfView        PDF
4.JasperReportsXlsView        EXCEL
5.JasperReportsMutiFormatView

Mapping one of these classes to a view name and a report file is simply a matter of adding the appropriate entries into the resource bundle configured in the previous section as shown here:

simpleReport.class=org.springframework.web.servlet.view.jasperreports.JasperReportsPdfView
simpleReport.url=/WEB-INF/reports/DataSourceReport.jasper

Here you can see that the view with name, simpleReport, is mapped to the JasperReportsPdfView class. This will cause the output of this report to be rendered in PDF format. The url property of the view is set to the location of the underlying report file.

13.7.2.3. About Report Files
JasperReports has two distinct types of report file: the design file, which has a .jrxml extension, and the compiled report file, which has a .jasper extension. Typically, you use the JasperReports Ant task to compile your .jrxml design file into a .jasper file before deploying it into your application. With Spring you can map either of these files to your report file and Spring will take care of compiling the .jrxml file on the fly for you. You should note that after a .jrxml file is compiled by Spring, the compiled report is cached for the life of the application. To make changes to the file you will need to restart your application.

JasperReports拥有两种不同的类型的报表文�g�Q�设计文�Ӟ��它是一个拥�?jrxml 扩展的文�Ӟ��和编译好的报表文件。一般，你��用ant��d��在你部��v��C��的程序中之前来编译你�?jrxml设计报表文�g。��用Spring 你可以媄��这些文件中的�Q一��C��的报表文�Ӟ��Spring��会��Z��在空闲时照顾�~�译.jrxml文�g�?你应当注意在一�?jrxml文�g被编译之后，�q�个�~�译的报表是被缓存的在你的application生命周期中。如果这些文件修改了�Q�你需要重新启动的你的�E�序�?/P>

13.7.2.4. Using JasperReportsMultiFormatView 使用JasperReportsMutiFormatView
The JasperReportsMultiFormatView allows for report format to be specified at runtime. The actual rendering of the report is delegated to one of the other JasperReports view classes - the JasperReportsMultiFormatView class simply adds a wrapper layer that allows for the exact implementation to be specified at runtime.

JasperReportsMutilFormatView允许你在�q�行时期指定报表的格式。报表的实际的表现是为委托到JasperReports 视图�cȝ��中的一�?-JasperMutilFormatView�cȝ��单的加了一个包装层允许在运行时期正��的实现被指定�?/P>

The JasperReportsMultiFormatView class introduces two concepts: the format key and the discriminator key. The JasperReportsMultiFormatView class uses the mapping key to lookup the actual view implementation class and uses the format key to lookup up the mapping key. From a coding perspective you add an entry to your model with the formay key as the key and the mapping key as the value, for example:

public ModelAndView handleSimpleReportMulti(HttpServletRequest request,
HttpServletResponse response) throws Exception {

String uri = request.getRequestURI();
String format = uri.substring(uri.lastIndexOf(".") + 1);

Map model = getModel();
model.put("format", format);

return new ModelAndView("simpleReportMulti", model);
}
In this example, the mapping key is determined from the extension of the request URI and is added to the model under the default format key: format. If you wish to use a different format key then you can configure this using the formatKey property of the JasperReportsMultiFormatView class.

By default the following mapping key mappings are configured in JasperReportsMultiFormatView:
Table 13.3. JasperReportsMultiFormatView Default Mapping Key Mappings

Mapping Key View Class
csv   JasperReportsCsvView
html JasperReportsHtmlView
pdf   JasperReportsPdfView
xls   JasperReportsXlsView

So in the example above a request to URI /foo/myReport.pdf would be mapped to the JasperReportsPdfView class. You can override the mapping key to view class mappings using the formatMappings property of JasperReportsMultiFormatView.

java世界畅谈 2005-06-29 10:24 发表评论

Remoting using Spring

java世界畅谈 — Fri, 24 Jun 2005 02:15:00 GMT

Considerations when choosing a technology �Q�当选择一个技术时候的考虑�Q?BR>Each and every technology presented here has its drawbacks. You should carefully consider you needs, the services your exposing and the objects you'll be sending over the wire when choosing a technology.
每个技术这里介�l�的都有它的�~�点。你应该仔细考虑你的需要，当你选择的时考虑你的暴露的服务和你将要发送关�pȝ��对象�?/P>

When using RMI, it's not possible to access the objects through the HTTP protocol, unless you're tunneling the RMI traffic. RMI is a fairly heavy-weight protocol in that it support full-object serialization which is important when using a complex data model that needs serialization over the wire. However, RMI-JRMP is tied to Java clients: It is a Java-to-Java remoting solution.
当我们��用RMI�Q�我们不可以通过http协议讉K��对象�Q�除非你打通RMI交通的隧道。RMI 是一个非帔R��量��协议�Q�在其中他支持的所有对象的序列化是非常重要的，当��用一个需要序列化兌��的复杂的数据模型。然而，RMI-JRMP 是依赖java客户端的�Q�它是java-to-java的远�E�解��x��案�?/P>

Spring's HTTP invoker is a good choice if you need HTTP-based remoting but also rely on Java serialization. It shares the basic infrastructure with RMI invokers, just using HTTP as transport. Note that HTTP invokers are not only limited to Java-to-Java remoting but also to Spring on both the client and server side. (The latter also applies to Spring's RMI invoker for non-RMI interfaces.)
Spring 的HTTP invoker 是一个不错的选择�Q�如果你需要基于HTTP的远�E�，而且需要java序列化回复。它使用RMI invoker分��n了基��l�构�Q�仅仅��用HTTP作�ؓ传输。注意HTTP invoker不是仅仅限制�l�java-to-java的远�E�而且是在客户端和服务器端的Spring.(后面的也应用到Spring 的RMI invoker为非RMI的接�?�?/P>

Hessian and/or Burlap might provide significant value when operating in a heterogeneous environment, because they explicitly allow for non-Java clients. However, non-Java support is still limited. Known problems include the serialization of Hibernate objects in combination with lazily initializing collections. If you have such a data model, consider using RMI or HTTP invokers instead of Hessian.
Hessian 和或 Burlap可以支持重要的��|��当在一个异质的环境操作�Q�因��Z��们明��的允许为非java 对象。然而非java对象是受限制的，知道的问题包括hibernate对象序列化与懒汉初始化集合的�l�合上。如果你有这��L��数据模型�Q�考虑使用RMI或HTTP invokers而不是Hessioan.

JMS can be useful for providing clusters of services and allowing the JMS broker to take care of load balancing, discovery and auto-failover. By default Java serialization is used when using JMS remoting but the JMS provider could use a different mechanism for the wire formatting, such as XStream to allow servers to be implemented in other technologies.

Last but not least, EJB has an advantage over RMI in that it supports standard role-based authentication and authorization and remote transaction propagation. It is possible to get RMI invokers or HTTP invokers to support security context propagation as well, although this is not provided by core Spring: There are just appropriate hooks for plugging in third-party or custom solutions here.

java世界畅谈 2005-06-24 10:15 发表评论