4_Spring常用的Annotation组件

Spring常用的Annotation组件

配置组件 Configure Components

@Configuration

@Autowired @Qualifier @Resource(name="")

// @Qualifier("dao")
// @Autowired
// Qualifier的意思是合格者，通过这个标示，表明了哪个实现类才是我们所需要的，
//        添加@Qualifier注解，需要注意的是@Qualifier的参数名称为我们之前定义
//        @Repository注解的名称之一
package com.zz.annotationdemo.injections.autowired;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/20 10:08
 * @Description: TODO
 */
@Configuration
@ComponentScan(value={"com.zz.annotationdemo.project.controller",
                      "com.zz.annotationdemo.project.dao",
                      "com.zz.annotationdemo.project.service"
                      })
public class MyConfig {

}


package com.zz.annotationdemo.injections.autowired;

import com.zz.annotationdemo.project.controller.UserController;
import com.zz.annotationdemo.project.dao.UserDao;
import com.zz.annotationdemo.project.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/20 10:19
 * @Description: TODO
 */
public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        UserController userController = (UserController)context.getBean("userController");

        UserService userService =  (UserService) context.getBean("userService");
        userService.print();

        UserDao userDao = (UserDao)context.getBean("dao");
        userDao.setFlag("0");

        System.out.println(userDao);
    }
}


package com.zz.annotationdemo.project.controller;

import com.zz.annotationdemo.project.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/19 16:22
 * @Description: TODO
 */
@Controller
public class UserController {
    @Autowired
    private UserService userService;
}


package com.zz.annotationdemo.project.dao;

import org.springframework.stereotype.Repository;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/19 16:22
 * @Description: TODO
 */
@Repository(value="dao")
public class UserDao {
    private String flag = "1";

    public void setFlag(String flag) {
        System.out.println("com.zz.annotationdemo.project.dao.UserDao.setFlag");
        this.flag = flag;
    }

    @Override
    public String toString() {
        return "UserDao{" +
                "flag='" + flag + '\'' +
                '}';
    }
}

package com.zz.annotationdemo.project.service;

import com.zz.annotationdemo.project.dao.UserDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/19 16:22
 * @Description: TODO
 */
@Service
public class UserService {

//    @Qualifier("dao")
//    @Autowired
    @Resource(name="dao")
    private UserDao userDao;

    public void print(){
        System.out.println("=========UserService:================"+userDao);
    }
}

@ComponentScan

@ComponentScan(value="com.zz",
               useDefaultFilters=false,
               includeFilters={@ComponentScan.Filter(type=FilterType.CUSTOM,value={MyTypeFilter.class})},
               excludeFilters={@ComponentScan.Filter(value={MyAnnotation.class})}
              )
public class MyConfig {
}


public class MyTypeFilter  implements TypeFilter {
    @Override
    public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
        String className = metadataReader.getClassMetadata().getClassName();
        System.out.println("------------------className:-------------------"+className);
        try {
            Class clazz = Class.forName(className);
            if(clazz.equals(User.class)){
                return false;
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            return false;
        }
        return true;
    }
}

@Scope

// prototype: 原型模式, 创建多个实例
// singleton: 单例
// request: 用于web模块,同一个请求只创建一个实例
// session: 用于web模块,同一个session只创建一个实例

package com.zz.annotationdemo.scope;

import com.zz.annotationdemo.project.entity.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Scope;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/20 9:54
 * @Description: TODO
 */
@Configuration
public class MyConfig {

    // 1. prototype: 原型模式,创建多个实例
    //2.  singleton: 单例模式
    //3.  request: 用于web模块,同一个请求只创建一个实例
    //4.  session: 用于web模块,同一个session创建一个实例
    @Scope("singleton")
    @Bean
    public User user(){
        return new User("zz",18);
    }
}

package com.zz.annotationdemo.scope;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/20 9:56
 * @Description: TODO
 */
public class MyTest {

    @Test
    public void test(){
        ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        Object user1 = context.getBean("user");
        Object user2 = context.getBean("user");
        System.out.println(user1);
        System.out.println(user2);
        System.out.println(user1 == user2);
    }
}


package com.zz.annotationdemo.project.entity;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Component;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/19 16:21
 * @Description: TODO
 */
public class User {
    private String name;
    private int age;

    public User() {
    }

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }


    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

@Lazy

@Configuration
public class MyConfig {

//    @Lazy
    @Bean
    public User user(){
        System.out.println("初始化user");
        return new User("tom",12);
    }
}

public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = 
              new AnnotationConfigApplicationContext(MyConfig.class);
        System.out.println("====初始化容器=========");
        context.getBean("user");
    }
}

@Conditional

@Configuration
@ComponentScan(value = "com.zz.annotationdemo.project")
public class MyConfig {

    @Conditional(value = WindowsCondition.class)
    @Bean
    public User tom(){
       return new User("tom",18);
    }

    @Conditional(value = WindowsCondition.class)
    @Bean
    public User mic(){
        return new User("mic",17);
    }

    @Conditional(value = LinuxCondition.class)
    @Bean
    public User james(){
        return new User("James",16);
    }

}

public class LinuxCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        String osName = context.getEnvironment().getProperty("os.name");
        if(osName.contains("Linux")){
            return true;
        }
        return  false;
    }
}

public class WindowsCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        Environment environment = context.getEnvironment();
        String osName = environment.getProperty("os.name");
        System.out.println("osName:"+osName);
        if( osName.contains("Windows") ){
            return true;
        }
        return false;
    }
}

public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = 
                     new AnnotationConfigApplicationContext(MyConfig.class);
        String[] beanDefinitionNames = context.getBeanDefinitionNames();
        System.out.println("==============test============================");
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
        User tom = (User)context.getBean("tom");
        User mic = (User)context.getBean("mic");
        User james = (User)context.getBean("james");
    }
}

@Import

@Configuration
@Import(value = {MyImportSelector.class,MyImportBeanDefinitionRegisterar.class})
public class MyConfig {

     @Bean
     public Company company(){
         return new Company();
     }

     @Bean
     public Member member(){
         return new Member();
     }

     //往 IoC容器中注册Bean的方式有以下几种:
     // 1. @Bean 直接导入单个类
     // 2. @ComponentScan 默认只扫描 @Controller @Service @Repository @Component
     // 3. @Import 快速给容器导入某个组件Bean
         // a. @Import 直接传参导入
         // b. ImportSelector 自定义导入规则
         // c. ImportBeanDefinitionRegistrar 使用BeanDefinitionRegistry可以手动注册到IoC容器
     //4. FactoryBean 把需要注入的对象封装为 FactoryBean
         // a. FactoryBean 负责将Bean注册到 容器的Bean
         // b. BeanFactory 负责从容器中获取Bean
     @Bean
     public User user(){
         return new User("tom",19);
     }

     @Bean
     public MyFactoryBean monkey(){
         return new MyFactoryBean();
     }
}

public class MyFactoryBean implements FactoryBean<Monkey> {
    @Override
    public Class<?> getObjectType() {
        return Monkey.class;
    }

    @Override
    public boolean isSingleton() {
        return false;
    }

    @Override
    public Monkey getObject() throws Exception {
        return new Monkey();
    }
}

public class MyImportBeanDefinitionRegisterar implements ImportBeanDefinitionRegistrar {
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        boolean company = registry.containsBeanDefinition("com.zz.annotationdemo.project.entity.Company");
        boolean member = registry.containsBeanDefinition("com.zz.annotationdemo.project.entity.Member");
        if(company && member){
            BeanDefinition beanDefinition = new RootBeanDefinition(Cat.class);
            registry.registerBeanDefinition("cat",beanDefinition);
        }
    }
}

public class MyImportSelector implements ImportSelector {
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.zz.annotationdemo.project.entity.Company",
                             "com.zz.annotationdemo.project.entity.Member"};
    }
}

public class MyTest {

    @Test
    public void test(){
        ApplicationContext context = 
               new AnnotationConfigApplicationContext(MyConfig.class);
        String[] beanDefinitionNames = context.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }

        Object monkey1 = context.getBean("monkey");
        System.out.println(monkey1);

        Object monkey2 = context.getBean("monkey");
        System.out.println(monkey2);
        //获取factoryBean
        Object factoryBean = context.getBean("&monkey");
        System.out.println(factoryBean);
    }
}

@PostConstruct 用于指定的初始化方法上 用在方法上

@PreDestroy 用于指定的销毁方法上

@DependsOn 用于Bean的初始化和销毁的顺序

interface : BeanPostProcessor

//Bean初始化和销毁方式
//1. @Bean 添加 initMethod 和 destroyMethod 配置
//2. 实现 InitializingBean 和 DisposableBean 
//3. JDK自带的:  @PostConstruct 和  @PreDestroy 注解到方法上

// 实现 BeanPostProcessor 在初始化Bean前、后分别做一些操作

package com.zz.annotationdemo.project.entity;

import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/20 9:22
 * @Description: TODO
 */
@Component
@Lazy
public class Airplain {
    public Airplain() {
        System.out.println("调用airplain的构造方法");
    }
    @PostConstruct
    public void addOil(){
        System.out.println("飞机飞行前加油");
    }
    public void run(){
        System.out.println("正在空中巡航");
    }
    @PreDestroy
    public void close(){
        System.out.println("飞机落地熄火");
    }
}

package com.zz.annotationdemo.project.entity;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/20 9:19
 * @Description: TODO
 */
public class Car {
    public Car() {
        System.out.println("调用Car的构造方法");
    }
    public void addOil(){
        System.out.println("行驶前加油");
    }
    public void run(){
        System.out.println("正在开车");
    }
    public void close(){
        System.out.println("停车熄火");
    }
}


package com.zz.annotationdemo.project.entity;

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/20 9:21
 * @Description: TODO
 */
@Component
@Lazy
public class Train implements InitializingBean, DisposableBean {
    @Override
    public void destroy() throws Exception {
        System.out.println("火车对象销毁");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("火车对象初始化");
    }
}

package com.zz.annotationdemo.lifecycle;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.stereotype.Component;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/20 9:46
 * @Description: TODO
 */
@Component
public class MyBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessBeforeInitialization:"+beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("postProcessAfterInitialization:"+beanName);
        return bean;
    }
}


package com.zz.annotationdemo.lifecycle;

import com.zz.annotationdemo.project.entity.Car;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScans;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Lazy;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/20 9:26
 * @Description: TODO
 */
@ComponentScans(value = {
           @ComponentScan(value = {"com.zz.annotationdemo.lifecycle"}),
        @ComponentScan(value = {"com.zz.annotationdemo.project.entity"}),
})
@Configuration
public class MyConfig {

    @Lazy
    @Bean(initMethod = "addOil",destroyMethod = "close")
    public Car car(){
       return new Car();
     }
}


package com.zz.annotationdemo.lifecycle;

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/20 9:30
 * @Description: TODO
 */
public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        System.out.println("=======start IoC==========");
//        context.getBean("car");
//        context.getBean("train");
        context.getBean("airplain");
        ((AnnotationConfigApplicationContext) context).close();


    }
}

@Primary

package com.zz.annotationdemo.injections.primary;

import com.zz.annotationdemo.project.dao.UserDao;
import com.zz.annotationdemo.project.service.UserService;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/20 16:19
 * @Description: TODO
 */
@Configuration
@ComponentScan(value={"com.zz.annotationdemo.project.controller",
                       "com.zz.annotationdemo.project.dao",
                       "com.zz.annotationdemo.project.service"})
public class MyConfig {

    @Primary
    @Bean(value="myUserDao")
    public UserDao userDaoN(){
        UserDao userDao = new UserDao();
        userDao.setFlag("2x");
        return userDao ;
    }

    @Bean(value="myUserDao")
    public UserDao userDao(){
        UserDao userDao =  new UserDao();
        userDao.setFlag("1x");
        return userDao;
    }



}


package com.zz.annotationdemo.injections.primary;

import com.zz.annotationdemo.project.dao.UserDao;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/20 16:23
 * @Description: TODO
 */
public class MyTest {

    @Test
    public void test(){
        ApplicationContext context  = new AnnotationConfigApplicationContext(MyConfig.class);
        UserDao userDao = (UserDao)context.getBean("myUserDao");
        System.out.println(userDao.toString());
    }
}

@Value @PropertySource @Bean

package com.zz.annotationdemo.injections.propertysource;

import com.zz.annotationdemo.project.entity.Bird;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/20 16:51
 * @Description: TODO
 */
@Configuration
@PropertySource(value={"classpath:values.properties"})
public class MyConfig {

    @Bean
    public Bird bird(){
        return new Bird("wkk",12);
    }
}

package com.zz.annotationdemo.injections.propertysource;

import com.zz.annotationdemo.project.entity.Bird;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.core.env.Environment;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/20 16:53
 * @Description: TODO
 */
public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
        String[] beanDefinitionNames = context.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            System.out.println(beanDefinitionName);
        }
        Bird bird = (Bird)context.getBean("bird");
        System.out.println(bird.toString());

        Environment environment = context.getEnvironment();
        String birdColor = environment.getProperty("bird.color");
        System.out.println("birdColor:"+birdColor);
    }
}


package com.zz.annotationdemo.project.entity;

import org.springframework.beans.factory.annotation.Value;

/**
 * @Author: itzz008
 * @DateTime: 2021/2/20 16:40
 * @Description: TODO
 */
public class Bird {
    //支持的数据类型
    // 1. 基本数据类型
    // 2. Spring EL表达式
    // 3. 通过配置文件赋值
    @Value("鹦鹉")
    private String name;
    @Value("#{6 - 1}")
    private int age;
    @Value("${bird.color}")
    private String color;

    public Bird(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    @Override
    public String toString() {
        return "Bird{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' +
                '}';
    }
}

赋值(自动装配)组件 Injection Components

@Component

@Service

@Controller

@Repository

@Value

@Autowired

@PropertySource 读取配置文件赋值

@Qualifier 如存在多个实例配合使用

@Primary 自动装配当出现多个候选者时候，被注解为 @Primary的Bean将作为首选者，否则将抛出异常

@Resource 默认按名称装配, 当找不到与名称匹配的bean才会按类型装配

织入组件 Weave Components

ApplicationContextAware

BeanDefinitionRegistryPostProcessor 实现了 BeanFactoryPostProcessor ，是Spring框架的BeanDefinitionRegistry的后处理器,用来注册额外的BeanDefinition

切面组件 Aspect Componnets

@EnableTransactionManagement 添加对事务管理的支持

@Transactional 配置声明式事务

注: 源码地址:

https://gitee.com/itzz008/design-pattern.git

design-pattern/ all-coding / spring-source / spring-componnets

注:pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.zz</groupId>
    <artifactId>spring-component</artifactId>
    <version>1.0</version>

    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>	
    </properties>

    <dependencies>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.4</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.9</version>
		</dependency>        
    </dependencies>

    <build>
       <finalName>${artifactId}</finalName>
       <resources>
           <resource>
               <directory>${basedir}/src/main/resources</directory>
               <includes>
                   <include>**/*</include>
               </includes>
           </resource>
           <resource>
               <directory>${basedir}/src/main/java</directory>
               <excludes>
                   <exclude>**/*.java</exclude>
                   <exclude>**/*.class</exclude>
               </excludes>
           </resource>
       </resources>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                    <encoding>UTF-8</encoding>
                    <compilerArguments>
                        <verbose />
                        <bootclasspath>${java.home}/lib/rt.jar</bootclasspath>
                    </compilerArguments>
                </configuration>
            </plugin>

            <plugin>
                <artifactId>maven-resources-plugin</artifactId>
                <version>2.5</version>
                <executions>
                    <execution>
                        <id>copy-resources</id>
                        <!-- here the phase you need -->
                        <phase>validate</phase>
                        <goals>
                            <goal>copy-resources</goal>
                        </goals>
                        <configuration>
                            <encoding>UTF-8</encoding>
                            <outputDirectory>${basedir}/target/classes</outputDirectory>
                            <resources>
                                <resource>
                                    <directory>src/main/resources</directory>
                                    <includes>
                                        <include>**/*.*</include>
                                    </includes>
                                    <filtering>true</filtering>
                                </resource>
                            </resources>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
            <plugin>
                <groupId>org.mortbay.jetty</groupId>
                <artifactId>maven-jetty-plugin</artifactId>
                <version>6.1.26</version>
                <configuration>
                    <webDefaultXml>src/main/resources/webdefault.xml</webDefaultXml>
                    <contextPath>/</contextPath>
                    <connectors>
                        <connector implementation="org.mortbay.jetty.nio.SelectChannelConnector">
                            <port>8080</port>
                        </connector>
                    </connectors>
                    <scanIntervalSeconds>0</scanIntervalSeconds>
                    <scanTargetPatterns>
                        <scanTargetPattern>
                            <directory>src/main/webapp</directory>
                            <includes>
                                <include>**/*.xml</include>
                                <include>**/*.properties</include>
                            </includes>
                        </scanTargetPattern>
                    </scanTargetPatterns>
                    <systemProperties>
                        <systemProperty>
                            <name>
                                javax.xml.parsers.DocumentBuilderFactory
                            </name>
                            <value>
                                com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl
                            </value>
                        </systemProperty>
                        <systemProperty>
                            <name>
                                javax.xml.parsers.SAXParserFactory
                            </name>
                            <value>
                                com.sun.org.apache.xerces.internal.jaxp.SAXParserFactoryImpl
                            </value>
                        </systemProperty>
                        <systemProperty>
                            <name>
                                javax.xml.transform.TransformerFactory
                            </name>
                            <value>
                                com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl
                            </value>
                        </systemProperty>
                        <systemProperty>
                            <name>org.eclipse.jetty.util.URI.charset</name>
                            <value>UTF-8</value>
                        </systemProperty>
                    </systemProperties>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <archive>
                        <addMavenDescriptor>false</addMavenDescriptor>
                    </archive>
                    <webResources>
                        <resource>
                            <!-- this is relative to the pom.xml directory -->
                            <directory>src/main/resources/</directory>
                            <targetPath>WEB-INF/classes</targetPath>
                            <includes>
                                <include>**/*.*</include>
                            </includes>
                            <!-- <excludes>
                                <exclude>**/local</exclude>
                                <exclude>**/test</exclude>
                                <exclude>**/product</exclude>
                            </excludes> -->
                            <filtering>true</filtering>
                        </resource>
                        <resource>
                            <!-- this is relative to the pom.xml directory -->
                            <directory>src/main/resources</directory>
                            <targetPath>WEB-INF/classes</targetPath>
                            <filtering>true</filtering>
                        </resource>
                    </webResources>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.zeroturnaround</groupId>
                <artifactId>javarebel-maven-plugin</artifactId>
                <executions>
                    <execution>
                        <id>generate-rebel-xml</id>
                        <phase>process-resources</phase>
                        <goals>
                            <goal>generate</goal>
                        </goals>
                    </execution>
                </executions>
                <version>1.0.5</version>
            </plugin>
        </plugins>
        <pluginManagement>
            <plugins>
                <!--This plugin's configuration is used to store Eclipse m2e settings
                    only. It has no influence on the Maven build itself. -->
                <plugin>
                    <groupId>org.eclipse.m2e</groupId>
                    <artifactId>lifecycle-mapping</artifactId>
                    <version>1.0.0</version>
                    <configuration>
                        <lifecycleMappingMetadata>
                            <pluginExecutions>
                                <pluginExecution>
                                    <pluginExecutionFilter>
                                        <groupId>
                                            org.zeroturnaround
                                        </groupId>
                                        <artifactId>
                                            javarebel-maven-plugin
                                        </artifactId>
                                        <versionRange>
                                            [1.0.5,)
                                        </versionRange>
                                        <goals>
                                            <goal>generate</goal>
                                        </goals>
                                    </pluginExecutionFilter>
                                    <action>
                                        <ignore></ignore>
                                    </action>
                                </pluginExecution>
                            </pluginExecutions>
                        </lifecycleMappingMetadata>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>