integration - Kenyth Zeng on Diigo

31 Aug 09

ask a bean factory to
configure a pre-existing object given the name of a
bean definition containing the configuration to be applied. The
spring-aspects.jar contains an
annotation-driven aspect that exploits this capability to allow
dependency injection of any object.
Spring will configure
new instances of the annotated type (Account in
this case) using a prototype-scoped bean definition with the same name
as the fully-qualified type name
(com.xyz.myapp.domain.Account).
16 more annotations...
- @Configurable(autowire
- dependencyCheck
- this means that the dependencies will not be available for use in the
  constructor bodies of the class. If you want the dependencies to be
  injected before the constructor bodies execute,
  and thus be available for use in the body of the constructors, then
  you need to define this on the
  @Configurable declaration like
  so:
  @Configurable(preConstruction=true)
- in order to obtain a reference to the bean
  factory that is to be used to configure new objects)
- factory-method="aspectOf"
- depends-on="org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect"
- The scope of a singleton aspect is the
  same as the scope of static members, that is to say
  there is one aspect instance per classloader that defines the type.
- If spring-aspects.jar is only added to the
  container wide classpath (and hence loaded by the shared parent
  classloader), all web applications will share the same aspect instance
- The aspect that interprets
  @Transactional annotations is the
  AnnotationTransactionAspect.
- Non-singleton aspects are harder to configure: however it is
  possible to do so by creating prototype bean definitions and using the
  @Configurable support from spring-aspects.jar to configure the
  aspect instances once they have bean created by the AspectJ
  runtime.
- If you have some @AspectJ aspects that you want to weave with
  AspectJ (for example, using load-time weaving for domain model types)
  and other @AspectJ aspects that you want to use with Spring AOP
- 'Vanilla' AspectJ LTW is effected using a Java (5+) agent, which is
  switched on by specifying a VM argument when starting up a JVM. It is
  thus a JVM-wide setting,
- 
  <context:load-time-weaver/>
- new ClassPathXmlApplicationContext("beans.xml", Main.class);
- 'aspectj-weaving' attribute.
- autodetect
  If the Spring LTW infrastructure can find at
  least one 'META-INF/aop.xml' file, then
  AspectJ weaving is on, else it is off. This is the default
  value.

26 Aug 09

Maven - Maven 2.x Integration for Eclipse

1. The Maven Integration for Eclipse (m2eclipse, Eclipse m2e);
2. Eclipse Integration for Apache Maven (Eclipse IAM), formerly Q for Eclipse.

maven.apache.org/eclipse-plugin.html - Preview

maven eclipse integration plugin

14 Jul 09

kiyaa - Google Code

code.google.com/kiyaa - Preview

UI GWT opensource integration javaee

15 Jun 09

日记 Django(Python)网站集成支付宝示例 - 好看簿图片博客：用照片记录生活

www.haokanbu.com/34642 - Preview

integration tutorial payment alipay python Django code api

18 May 09

Apache Tomcat 6.0 - Connectors How To

tomcat.apache.org/...connectors.html - Preview

http tomcat config doc integration

When using a single server, the performance when using a native webserver in
front of the Tomcat instance is most of the time significantly worse than a
standalone Tomcat with its default HTTP connector, even if a large part of the web
application is made of static files.

27 Apr 09

6.4 Multi bundle integration testing

static.springsource.com/...ch06s04.html - Preview

testing spring-dm-server integration tutorial doc

the use of
classpath*: with respect to the module-context.xml path. This will
cause Spring to look for files that match that path in all of the bundles on the classpath meaning that all
the application beans will be instantiated:
When this test is run, Spring creates an ApplicationContext that is built
from the module-context.xml configuration files from all of the bundles.

Integration Testing

msdn.microsoft.com/...aa292128(VS.71).aspx - Preview

testing integration SE

it tends to minimize the need for drivers. However, the need for stubs complicates test management
the inputs for functions are integrated in the bottom-up pattern discussed above. The outputs for each function are then integrated in the top-down manner.
2 more annotations...
- umbrella approach, requires testing along functional data and control-flow paths
- utility modules are tested early in the development process and the need for stubs is minimized. The downside, however, is that the need for drivers complicates test management and high-level logic and data flow are tested late.

6.2 Single bundle integration testing

static.springsource.com/...ch06s02.html - Preview

spring-dm-server doc tutorial testing integration

One of the most common forms of integration testing is ensuring that the object relational mapping in an
application is working properly.

16 Apr 09

IT Stream: Full-Text Search for Database Using Lucene Search Engine

it-stream.blogspot.com/...search-for-database-using.html - Preview

best-practice lucene database integration blog performance tuning

MySQL has full-text indexing capabilities built in
The main rule for optimizing search engines is to reduce number of hard drive seeks to minimum.
11 more annotations...
- First way to optimize index structure is to use combined field.
- +icq:Y +jabber:Y
- like IM:ICQ for one term search, or IM:(ICQ YAH) for multiple term search.
- As a result we have 1 field instead of 6, much less drive seeks and much faster indexing and search.
- always call writer.optimize() after index update.
- Reducing number of field make indexing and search much faster.
- Do not use compound file format during indexing. writer.setUseCompoundFile(false); If you want to keep index in single file, turn it on when indexing is complete.
- Keep Searcher opened and reuse it for every search. When index changes make sure to recreate you Searcher.
- Use quotes "" only to perform exact phrase searches. field:term is much better than field:"term"
- Merge Factor. This is a number of segments writer keeps in memory (RAMDirectory) before flushing them to disk.
- Keeping it to default 10 or 20 turns out to be the most reasonable choice.

hibernate.org - Hibernate Search

www.hibernate.org/410.html - Preview

hibernate search lucene integration opensource

it becomes increasingly more difficult to index a more complex object domain model - keeping the index up to date, dealing with the mismatch between the index structure and the domain model, querying mismatches, and so on.

Re: Syncing lucene index with a database

www.mail-archive.com/...msg25679.html - Preview

integration lucene database indexing discussion

 
Alternatively I have thought of using Lucene purely for search to
return just the primary key of items from our database table, then query
the database for those items and get the most up to date data from the
database to actually display our search results.  This would let us use
Lucene's superior searching capabilities and searching speed, but would
still require us to pull the data to be displayed from the database.
 
Another option is that we could do the same, but only return the fields
that could change frequently.  This would use Lucene to store and index
the majority of what is displayed on a search results page, only using
the database to return the 2 or 3 fields that might change in a search
for each row that lucene returns.

        
      

18 Dec 08

The V N Albuquerque Blog: Spring MVC and AJAX with JSON

techvj.blogspot.com/...cisions-to-be-taken-while.html - Preview

jquery integration springframework spring-web-mvc blog tutorial example

InfoQ: Your First Cup of Web 2.0 - A Quick Look at jQuery, Spring MVC, and XStream/Jettison

www.infoq.com/...First-Cup-Web-2.0-Joel-Confino - Preview

tutorial jquery springframework spring-web-mvc integration

19 Nov 08

JAX-RS Spring Integration :: New York Java Consultant : Weblog

www.jroller.com/...jax_rs_spring_integration - Preview

blog starred JAX-RS REST integration springframework spring-web-mvc toread

Integrating JAX-RS and Spring MVC | Javalobby

java.dzone.com/...integrating-jax-rs-and-spring- - Preview

toread integration REST JAX-RS spring-web-mvc starred

All you need to do is <import resource:"springmvc-resteasy.xml"/>.
JAX-RS can be set up to handle XML and JSON
interactions

22 Oct 08

Chapter 6. Aspect Oriented Programming with Spring

static.springframework.org/...aop.html - Preview

spring-aop aspectj aop doc reference springframework integration

offer fully typed advice
Field interception
is not implemented
49 more annotations...
- If you need to advise
  field access and update join points, consider a language such as
  AspectJ.
- provide a close integration between AOP implementation and Spring IoC to
  help solve common problems in enterprise applications.
- There are some things you cannot do easily or
  efficiently with Spring AOP, such as advise very fine-grained objects
  (such as domain objects typically): AspectJ is the best choice in such
  cases.
- CGLIB is used by default if a business
  object does not implement an interface.
- autoproxying beans based on whether or
  not they are advised by those aspects.
- <aop:aspectj-autoproxy/>
- You will also need two AspectJ libraries on the classpath of your
  application: aspectjweaver.jar
  and aspectjrt.jar.
- In Spring AOP, it is not possible to have
  aspects themselves be the target of advice from other aspects.
- an additional PCD named
  'bean'
- An introduction is made using the
  @DeclareParents annotation
- Spring supports AspectJ's perthis and
  pertarget instantiation models (percflow, percflowbelow, and pertypewithin are not
  currently supported).
- The
  recommended usage pattern is to use either just the
  <aop:config> style, or just the
  AutoProxyCreator style.
- Using the schema support, an aspect is simply a regular Java
  object defined as a bean
- When combining pointcut sub-expressions, '&&' is awkward
  within an XML document, and so the keywords 'and', 'or' and 'not' can be
  used in place of '&&', '||' and '!' respectively.
- does not have a direct equivalent in AspectJ.
- self-contained aspect that has a single piece
  of advice.
- introducing an Idempotent
  annotation
- @annotation(com.xyz.myapp.service.Idempotent)
- If you need to advise objects not managed by
  the Spring container (such as domain objects typically), then you will
  need to use AspectJ.
- ask a bean factory to
  configure a pre-existing object given the name of a
  bean definition containing the configuration to be applied.
- Domain objects often fall into this
  category because they are often created programmatically using the
  new operator, or by an ORM tool as a result of a
  database query.
- @Configurable
- prototype-scoped
- omit the
  id attribute
- enable Spring dependency checking
- If this attribute is set to true, then Spring will validate after
  configuration that all properties (which are not primitives or
  collections) have been set.
- dependencies will not be available for use in the
  constructor bodies of the class.
- @Configurable(preConstruction=true)
- Instances of @Configurable objects
  created before the aspect has been configured will
  result in a warning being issued to the log and no configuration of the
  object taking place.
- be able to configure such aspects using
  Spring.
- Non-singleton aspects are harder to configure: however it is
  possible to do so by creating prototype bean definitions and using the
  @Configurable support from spring-aspects.jar to configure the
  aspect instances once they have bean created by the AspectJ
  runtime.
- It is
  thus a JVM-wide setting, which may be fine in some situations, but often
  is a little too coarse.
- Spring-enabled LTW enables you to switch on LTW
  on a per-ClassLoader basis
- this support enables load-time weaving
  without making any modifications to the application server's
  launch script that will be needed to add
  -javaagent:path/to/aspectjweaver.jar or (as we describe later in this
  section) -javaagent:path/to/spring-agent.jar.
- 
  <context:load-time-weaver/>
- @AspectJ-style
- mean that your
  aspects are then both valid AspectJ and Spring
  AOP aspects.
- The key component in Spring's LTW support is the
  LoadTimeWeaver interface (in the
  org.springframework.instrument.classloading
  package)
- Please note that you almost certainly will need to
  be using an ApplicationContext as your
  Spring container - typically a
  BeanFactory will not be enough because
  the LTW support makes use of
  BeanFactoryPostProcessors
- To enable the Spring Framework's LTW support, you need to
  configure a LoadTimeWeaver
- <context:load-time-weaver/>
- only available in versions of Spring 2.5 and
  later.
- TomcatInstrumentableClassLoader
- possible to specify exactly which
  LoadTimeWeaver implementation that you
  wish to use
- retrieved from the Spring container using the well-known name
  'loadTimeWeaver'
- The actual
  ClassFileTransformer that does the LTW is the
  ClassPreProcessorAgentAdapter (from the
  org.aspectj.weaver.loadtime package) class.
- If the Spring LTW infrastructure can find at
  least one 'META-INF/aop.xml' file, then
  AspectJ weaving is on, else it is off. This is the default
  value.
- For web applications deployed onto Apache Tomcat 5.0 and above,
  Spring provides a TomcatInstrumentableClassLoader
  to be registered as the web app class loader.
- make instrumentation available to all deployed web
  applications

21 Oct 08

AOP@Work: Dependency injection with AspectJ and Spring

www-128.ibm.com/...j-aopwork13.html - Preview

aop aspectj springframework IoC instantiation integration domain entity starred article

In the book Domain-Driven Design, Eric Evans argues
persuasively for hiding objects from the details of their
configuration and association establishment:
agrees not to
go out searching for the resources it needs, partners it collaborates
with, or services it uses.
11 more annotations...
- In an integration test
  or when the application is in production, a broker is responsible
  for finding the resources that satisfy the object's dependencies and
  passing them to it.
- A broker such as the Spring framework has four key responsibilities, which I return to throughout the article:
  
  Determining that an object needs configuring (typically because it
  has just been created)
  Determining the dependencies of the object
  Finding the objects that satisfy those dependencies
  Configuring the object with its dependencies
- it's good practice to implement an aspect as a
  lightweight controller.
- tell Spring to use the aspectOf() method as a factory method for obtaining the aspect instance.
- what about aspects that have other
  lifecyles such as perthis, pertarget, or even percflow aspects?
- initialization((@SpringConfigured *).new(..))
- beanFactory.applyBeanPropertyValues(newInstance,beanName);
- if you define a percflow aspect, then AspectJ creates a new aspect instance
  each time the associated control flow is entered, and Spring configures each of the aspects as it is created.
- So far, I've used the bean definition read by the Spring container to
  determine the dependencies of an object. A variation on this theme uses
  contract interfaces for a client to declare its requirements.
- the
  objects that a client needs to collaborate with will change at run time.
- possible to
  defer injection of a dependency until a client first needs it, and to
  re-inject the client with the most up-to-date version of the dependency
  each time it is referenced.

The Aspects Blog: What the teacher said (using AspectJ with Spring part II)

www.aspectprogrammer.org/...what_the_teache.html - Preview

aspectj springframework integration IoC instantiation

aspects in AspectJ are implicitly constructed on point of first reference
AspectJ will actually give a compile-time error if you attempt to define a non-zero argument constructor in an aspect.
1 more annotations...
- factory method is aspectOf

06 Oct 08

麦当劳上海 - Google Maps

maps.google.com/maps - Preview

ideas innovation integration mashup Google Maps tools

22 Aug 08

Running JSP Through Apache with mod_proxy_ajp or mod_jk2 - RimuHosting

rimuhosting.com/mod_jk2_and_mod_proxy_ajp.jsp - Preview

integration apache tomcat starred config

If you are on a newer distro
(e.g. FC5, Centos5 and Debian Etch) with Apache 2.2 you would use mod_proxy
We do not recommend this method, since
then Tomcat would need to run as a privileged user. Which has security
implications.
11 more annotations...
- This module
  pretty much deprecates the need for mod_jk2.
- via a socket
- When using Apache as a front end, it is best to not use
  a 'ROOT' mounted webapp.
- This Location tag will direct requests to http://yourdomain/jsp-examples to the
  jsp-examples webapp (if one exists) on your Servlet engine.
- on some servers there seems to be a problem where the
  VirtualHost is ignored, and the Location is used across all domains. In this case you will
  need to setup a workers2.properties.
- ServerAlias *.yourdomain.com
- <Alias>www.your2nddomain.com</Alias>
- a Location / inside one VirtualHost ends up
  applying to all VirtualHosts on the server. So that all requests go to Tomcat, not
  just the requests for the intended domain.
- but never sends it back because it never requests a page that matches the cookies location.
- If your application is not accessible at /myapp though, it won't ever send that cookie back in a request, so you don't appear to have working sessions.
- ProxyPassReverseCookiePath /myapp /

Kenyth Zeng's Library tagged integration → View Popular

7.8 Using AspectJ with Spring applications -- Spring Framework 3.0 Reference

Maven - Maven 2.x Integration for Eclipse

kiyaa - Google Code

日记 Django(Python)网站集成支付宝示例 - 好看簿图片博客：用照片记录生活

Apache Tomcat 6.0 - Connectors How To

6.4 Multi bundle integration testing

Integration Testing

6.2 Single bundle integration testing

IT Stream: Full-Text Search for Database Using Lucene Search Engine

hibernate.org - Hibernate Search

Re: Syncing lucene index with a database

The V N Albuquerque Blog: Spring MVC and AJAX with JSON

InfoQ: Your First Cup of Web 2.0 - A Quick Look at jQuery, Spring MVC, and XStream/Jettison

JAX-RS Spring Integration :: New York Java Consultant : Weblog

Integrating JAX-RS and Spring MVC | Javalobby

Chapter 6. Aspect Oriented Programming with Spring

AOP@Work: Dependency injection with AspectJ and Spring

The Aspects Blog: What the teacher said (using AspectJ with Spring part II)

麦当劳上海 - Google Maps

Running JSP Through Apache with mod_proxy_ajp or mod_jk2 - RimuHosting

Selected Tags

Related Tags

Sponsored Links

Top Contributors

Groups interested in integrat...

ED843-LMU

ecycle

Sustainable Electronics Initiative (SEI)

IWB

nas_usb-storage server

Web 2.0