Vivek Viswanathan's List: Spring Framework

• Advice is associated with a pointcut expression, and runs before,  after, or around method executions matched by the pointcut. The pointcut  expression may be either a simple reference to a named pointcut, or a  pointcut expression declared in place.

  • Can I tag certain highlights

• • It seems that we can do this only while using JBoss but not in a standalong env. I read another post somewhere else stating that its is bug in springframework where in we cannot register a MBean to a remote MBeanServer, since MBeanServerFactor only can get reference to a locally running MBean

• <util:property-path/>

  • I realy should use this more often.

• Spring portfolio also  features Spring Web Services, a solution  for contract-first, document-driven web services - highly recommended for building modern, future-proof  web services

• Spring Web Services aims to facilitate contract-first SOAP service development, allowing for the creation of  flexible web services using one of the many ways to manipulate XML payloads.  The product is based on Spring itself, which means you can use the Spring concepts such as dependency   injection as an integral part of your Web service

  • nullIdeally, I we should be using this method of defining web servies - contract-first. Start with defining the XSD (i.e the contract) and then look into implementing either side of the the contract. -- 2009-11-11
    Thinking about the contract driving webservices, this seems a lot similar to what osgi extensions has to offer i.e the osgi extension defines the contract. On these basis can we define the osgi contract using WS XSD? -- 2009-11-11
    

• When creating Web services, there are two development styles: Contract Last and   Contract First. When using a contract-last approach, you start with the Java code, and   let the Web service contract (WSDL, see sidebar) be generated from that.  When using contract-first, you start with the WSDL contract, and use Java to implement said contract. 

  What is WSDL?

    WSDL stands for Web Services Description Language. A WSDL file is an XML document that describes a Web   service. It specifies the location of the service and the operations (or methods) the service exposes.  For more information about WSDL, refer to the   WSDL specification, or read the   WSDL tutorial 

    Spring-WS only supports the contract-first development style, and this section explains why

• binding, which tells the client how  to invoke the operations you've just defined
• service, which tells it  where to invoke it
• The name of this file is derived from the name of the attendant servlet (in this case  'spring-ws') with '-servlet.xml' appended to it. So if you defined a  MessageDispatcherServlet with the name 'dynamite', the name of the  Spring-WS-specific configuration file would be 'WEB-INF/dynamite-servlet.xml'.

1 more annotation...

• Spring Certification Mock

  • Search with in Spring Reference Doc: http://www.google.co.uk/search?hl=en&q=site%3Ahttp%3A%2F%2Fstatic.springsource.org%2Fspring%2Fdocs%2F2.5.x%2Freference%2F&btnG=Search&meta=&aq=f&oq=
• Choose between getter and setter injection

  • Getter Injection: http://static.springsource.org/spring/docs/2.5.x/reference/beans.html#beans-factory-method-injection
    Setter Injection : http://static.springsource.org/spring/docs/2.5.x/reference/beans.html#beans-factory-collaborators
  Add Sticky Note
• Demonstrate knowledge of how the container's support for collections and maps

  • Spring Ref Doc: http://static.springsource.org/spring/docs/2.5.x/reference/beans.html#beans-collection-elements
  Add Sticky Note
• Factory Beans

  • Ref Doc: http://static.springsource.org/spring/docs/2.5.x/reference/beans.html#beans-factory-extension
  Add Sticky Note
• Demonstrate knowledge of factory methods and

  • http://static.springsource.org/spring/docs/2.5.x/reference/beans.html#beans-factory-nature
  Add Sticky Note
• Be familiar with Spring's supporting namespaces, e.g. context, util

  • http://static.springsource.org/spring/docs/2.5.x/reference/xsd-config.html
  Add Sticky Note
• Bean definition inheritance

  • Spring Ref Doc: http://static.springsource.org/spring/docs/2.5.x/reference/beans.html#beans-child-bean-definitions
  Add Sticky Note
• Property Editors

  • Spring Doc Ref: http://static.springsource.org/spring/docs/2.5.x/reference/validation.html#beans-beans-conversion
  Add Sticky Note
• Bean Naming

  • http://static.springsource.org/spring/docs/2.5.x/reference/beans.html#beans-beanname
  Add Sticky Note
• Importing configuration files

  • http://static.springsource.org/spring/docs/2.5.x/reference/beans.html#beans-factory-xml-import
  Add Sticky Note
• The util namespace

  • http://static.springsource.org/spring/docs/2.5.x/reference/xsd-config.html#xsd-config-body-schemas-util
  Add Sticky Note
• Know how to configure web.xml to bootstrap Spring with the ContextLoaderListener
• The life-cycle of an application context

  • http://static.springsource.org/spring/docs/2.5.x/reference/beans.html#beans-factory-lifecycle
  Add Sticky Note
• Bean scoping

  • http://static.springsource.org/spring/docs/2.5.x/reference/beans.html#beans-factory-scopes
  Add Sticky Note
• Explain why good test coverage is important in respect to refactoring, agile programming and continuous integratio

  • Test-driven development offers more than just simple validation of correctness, but can also drive the design of a program. By focusing on the test cases first, one must imagine how the functionality will be used by clients (in the first case, the test cases). So, the programmer is only concerned with the interface and not the implementation. This benefit is complementary to Design by Contract as it approaches code through test cases rather than through mathematical assertions or preconceptions.
    
    The power test-driven development offers is the ability to take small steps when required. It allows a programmer to focus on the task at hand as the first goal is to make the test pass
    Another advantage is that test-driven development, when used properly, ensures that all written code is covered by a test. This can give the programming team, and subsequent users, a greater level of trust in the code.
    The early and frequent nature of the tests helps to catch defects early in the development cycle, preventing them from becoming endemic and expensive problems. Eliminating defects early in the process usually avoids lengthy and tedious debugging later in the project.
    
    TDD can lead to more modularized, flexible, and extensible code. This effect often comes about because the methodology requires that the developers think of the software in terms of small units that can be written and tested independently and integrated together later. This leads to smaller, more focused classes, looser coupling, and cleaner interfaces.
    
    source: wikipedia
• Unit testing with stubs

  • http://static.springsource.org/spring/docs/2.5.x/reference/testing.html#unit-testing
  Add Sticky Note
• Integration testing with Spring

  • 8.3 Integration Tests: http://static.springsource.org/spring/docs/2.5.x/reference/testing.html#integration-testing
  Add Sticky Note
• Local Transaction Management

  • Spring Framework 3 : http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/ch10s02.html#d0e17601
  Add Sticky Note
• Using Spring Security's Tag Libraries

  • Setting up Tag libs: http://static.springsource.org/spring-security/site/docs/2.0.x/reference/supporting-infrastructure.html#taglib
  Add Sticky Note
• Know how to display the authentication object with <security:authentication property="principal.username">

  • http://static.springsource.org/spring-security/site/docs/2.0.x/reference/authentication-common-auth-services.html#authentication-taglibs
  Add Sticky Note
• Understand how to hide a section based on a role with <security:authorize ifAnyGranted="ROLE_ADMIN">

  • http://static.springsource.org/spring-security/site/docs/2.0.x/reference/authorization-common.html#authorization-taglibs
  Add Sticky Note

19 more annotations...

• AuthenticationManager
• authentication manager
• springSecurityFilterChain

  • This name is used (by default) by the DelegatingFilterProxy to look up a spring bean with the same name. @see DelegatingFilterProxy#setTargetBeanName
  Add Sticky Note
• This provides a hook into the Spring Security web infrastructure. DelegatingFilterProxy  is a Spring Framework class which delegates to a filter implementation which is defined as a Spring bean in your  application context. In this case, the bean is named "springSecurityFilterChain", which is an internal infrastructure   bean created by the namespace to handle web security. Note that you should not use this bean name yourself.   Once you've added this to your web.xml, you're ready to start editing your application  context file. Web security services are configured using the <http>  element.

• If you are familiar with previous versions of the framework, you can probably  already guess roughly what's going on here. The <http> element is   responsible for creating a FilterChainProxy and the  filter beans which it uses. Common issues like incorrect filter ordering are no   longer an issue as the filter positions are predefined.

   

  The <authentication-provider>  element creates a DaoAuthenticationProvider  bean and the <user-service> element creates an   InMemoryDaoImpl. A ProviderManager  bean is always created by the namespace processing system and the  DaoAuthenticationProvider  is automatically registered with it. You can find more detailed   information on the beans that are created in the namespace appendix.  

  • Spring in Action (2nd Edition) talks about the this previous version of Spring Security
  Add Sticky Note
• You can use a custom password encoder bean by using the ref attribute of password-encoder. This should  contain the name of a bean in the application context which is an instance of Spring Security's PasswordEncoder  interface.

4 more annotations...

• <context-param>  <param-name>contextConfigLocation</param-name>  <param-value>/WEB-INF/daoContext.xml /WEB-INF/applicationContext.xml</param-value> </context-param>
• The listener inspects the  'contextConfigLocation' parameter. If the parameter  does not exist, the listener will use  /WEB-INF/applicationContext.xml as a default. When it  does exist, it will separate the String using  predefined delimiters (comma, semicolon and whitespace) and use the  values as locations where application contexts will be searched for.  Ant-style path patterns are supported as well: e.g.  /WEB-INF/*Context.xml (for all files whose name ends  with "Context.xml", residing in the "WEB-INF" directory) or  /WEB-INF/**/*Context.xml (for all such files in any  subdirectory of "WEB-INF").

• Onto specifics... all that one need do is to declare a  ContextLoaderListener  in the standard J2EE servlet web.xml file of one's web application,  and add a contextConfigLocation <context-param/> section  (in the same file) that defines which set of Spring XML cpnfiguration files to load. 

    Find below the <listener/> configuration: 

  <listener>   <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener>

  	Note
  	Listeners were added to the Servlet API in version 2.3; listener startup order was  finally clarified in Servlet 2.4. If you have a Servlet 2.3 container, you can use the  ContextLoaderServlet  to achieve the same functionality in a 100% portable fashion (with respect to startup order).

    Find below the <context-param/> configuration: 

  <context-param>   <param-name>contextConfigLocation</param-name>   <param-value>/WEB-INF/applicationContext*.xml</param-value> </context-param>

    If you don't specify the contextConfigLocation  context parameter, the ContextLoaderListener will look  for a file called /WEB-INF/applicationContext.xml to load.  Once the context files are loaded, Spring creates a  WebApplicationContext  object based on the bean definitions and stores it in the  ServletContext of one's web application. 

    All Java web frameworks are built on top of the Servlet API, and so one can  use the following code snippet to get access to this 'business context'  ApplicationContext created by the  ContextLoaderListener

• Beginning with Spring 2.0, the  @Repository annotation was introduced as  a marker for any class that fulfills the role or  stereotype of a repository (a.k.a. Data Access  Object or DAO). Among the possibilities for leveraging such a marker is  the automatic translation of exceptions as described in Section 12.6.4, “Exception Translation”.

  • @Repository
    public class ProductDaoImpl implements ProductDao {
    
    // class body here...
    
    }
    
    <beans>
    
    <!-- Exception translation bean post processor -->
    <bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/>
    
    <bean id="myProductDao" class="product.ProductDaoImpl"/>
    
    </beans>
    
    The postprocessor will automatically look for all exception translators (implementations of the PersistenceExceptionTranslator interface) and advise all beans marked with the @Repository annotation so that the discovered translators can intercept and apply the appropriate translation on the thrown exceptions.
    
    http://static.springsource.org/spring/docs/2.5.x/reference/orm.html#orm-jpa-exceptions

• i didn't attend any spring course for the exam 
   
  for the preparation of the exam, i have found very little resource about the exam, and just can find some little guide here: 
   
   
  http://www.coderanch.com/t/423549/Product-Other-Ce...n/Spring-Certification#1927006 
   
  so i follow it: 
   
  - basically i follow the suggested topics 
  - i read through the official spring reference doc (2.5) 
  - read through the spring pro 2.5 for the suggested topics 
  - read through the spring in action for the suggested topics 
  - no code practice, just read 
  - go through the spring exam questions on http://www.javablackbelt.com/Home.wwa (i can just access the basic questions) 
   
  i don't have enough time for the exam preparation (just study in the weekend of 2 weeks) 
  so i don't have written any code during the exam preparation,  
  and this should be ok as long as you really understand the spring (basically i should understand most of the topics well before) 
   
  basically the exam is more or less similar described in the above url (http://www.coderanch.com/t/423549/Product-Other-Ce...n/Spring-Certification#1927006)