.net 转JAVA beans 定义

一、XML定义

所有的配置元数据转换成一组构成每个 bean 定义的下列属性。

属性	描述
class	这个属性是强制性的，并且指定用来创建 bean 的 bean 类。
name	这个属性指定唯一的 bean 标识符。在基于 XML 的配置元数据中，你可以使用 ID 和/或 name 属性来指定 bean 标识符。
scope	这个属性指定由特定的 bean 定义创建的对象的作用域，它将会在 bean 作用域的章节中进行讨论。
constructor-arg	它是用来注入依赖关系的，并会在接下来的章节中进行讨论。
properties	它是用来注入依赖关系的，并会在接下来的章节中进行讨论。
autowiring mode	它是用来注入依赖关系的，并会在接下来的章节中进行讨论。
lazy-initialization mode	延迟初始化的 bean 告诉 IoC 容器在它第一次被请求时，而不是在启动时去创建一个 bean 实例。
initialization 方法	在 bean 的所有必需的属性被容器设置之后，调用回调方法。它将会在 bean 的生命周期章节中进行讨论。
destruction 方法	当包含该 bean 的容器被销毁时，使用回调方法。它将会在 bean 的生命周期章节中进行讨论。

在 resources下新建 applicationContext.xml
 

public static void main(String[] args) {
        //获取IOC 初始化时bean立即加载
        //读配置文件
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
//        BookDao bookDao = (BookDao)app.getBean("bookDao") ;
//        bookDao.save();

        //获取bean方式1
        BookService bookSvr = (BookService)app.getBean("bookService") ;
        bookSvr.save();

         //获取bean方式2
        BookService bookSvr2 = app.getBean("bookService",BookService.class) ;
    }

set 属性注入 

    <bean id="bookService" class="org.example.service.Impl.BookServiceImpl">
        <!--        配置service与dao的关系 name 指类里面属性的名称，ref 指提前定义的bean-->
        <property name="bookDao" ref="bookDao"></property>
        <property name="orderDao" ref="orderDao"></property>
        <property name="OrderMoney" value="10"></property>
    </bean>

构造器注入

<bean id="bookService" class="org.example.service.Impl.BookServiceImpl">
        <!--        配置service与dao的关系 name 指类里面属性的名称，ref 指提前定义的bean-->
        <constructor-arg name="bookDao" ref="bookDao"></constructor-arg>
        <constructor-arg name="orderDao" ref="orderDao"></constructor-arg>
    </bean>

值注入

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value=""></property>
        <property name="url" value=""></property>
        <property name="username" value=""></property>
        <property name="password" value=""></property>
    </bean>

使用context加载properties文件

（1）首先开启context命名空间
添加 xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation=" 增加下面2行
 http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
        
    </beans>

（2）使用context加载properties文件

<context:property-placeholder location="classpath:*.properties" system-properties-mode="NEVER"></context:property-placeholder>

3、使用属性占位符
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
    <property name="driverClassName" value="${jdbc.driver}"></property>
    <property name="url" value="${jdbc.url}"></property>
    <property name="username" value="${jdbc.username}"></property>
    <property name="password" value="${jdbc.password}"></property>
</bean>

二、注解定义 

1、在 resources下新建 applicationContext.xml

public class App {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        BookDao bookDao = app.getBean("bookDao",BookDao.class);
        bookDao.save();

        BookService bookService = app.getBean("bookSvr", BookService.class);
        bookService.save();
    }
}

<context:component-scan base-package="com.wjx.betalot" <!-- 扫描的基本包路径 -->
                        annotation-config="true" <!-- 是否激活属性注入注解 -->
                        name-generator="org.springframework.context.annotation.AnnotationBeanNameGenerator"  <!-- Bean的ID策略生成器 -->
                        resource-pattern="**/*.class" <!-- 对资源进行筛选的正则表达式，这边是个大的范畴，具体细分在include-filter与exclude-filter中进行 -->
                        scope-resolver="org.springframework.context.annotation.AnnotationScopeMetadataResolver" <!-- scope解析器 ，与scoped-proxy只能同时配置一个 -->
                        scoped-proxy="no" <!-- scope代理，与scope-resolver只能同时配置一个 -->
                        use-default-filters="false" <!-- 是否使用默认的过滤器，默认值true -->
                                  >
            <!-- 注意：若使用include-filter去定制扫描内容，要在use-default-filters="false"的情况下，不然会“失效”，被默认的过滤机制所覆盖 -->                   
            <!-- annotation是对注解进行扫描 -->
            <context:include-filter type="annotation" expression="org.springframework.stereotype.Component"/> 
            <!-- assignable是对类或接口进行扫描 -->
            <context:include-filter type="assignable" expression="com.wjx.betalot.performer.Performer"/>
            <context:include-filter type="assignable" expression="com.wjx.betalot.performer.impl.Sonnet"/>
            
            <!-- 注意：在use-default-filters="false"的情况下，exclude-filter是针对include-filter里的内容进行排除 -->
            <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
            <context:exclude-filter type="assignable" expression="com.wjx.betalot.performer.impl.RainPoem"/>
            <context:exclude-filter type="regex" expression=".service.*"/> 
 
</context:component-scan>

<context:component-scan>查找使用构造型（stereotype）注解所标注的类，如@Component(组件)，@Service（服务），@Controller（控制器），@Repository（数据仓库）。

back-package：标识了<context:component-scan>元素所扫描的包，可以使用一些通配符进行配置

annotation-config:<context:component-scan>元素也完成了<context:annotation-config>元素的工作，开关就是这个属性，false则关闭属性注入注解功能

name-generator:这个属性指定你的构造型注解，注册为Bean的ID生成策略，这个生成器基于接口BeanNameGenerator实现generateBeanName方法，你可以自己写个类去自定义策略。这边，我们可不显示配置，它是默认使用org.springframework.context.annotation.AnnotationBeanNameGenerator生成器，也就是类名首字符小写的策略，如Performer类，它注册的Bean的ID为performer.并且可以自定义ID，如@Component("Joy").这边简单贴出这个默认生成器的实现。

use-default-filters：是否使用默认的扫描过滤。

<context:include-filter> ：用来告知哪些类需要注册成Spring Bean,使用type和expression属性一起协作来定义组件扫描策略。type有以下5种

过滤器类型	描述
annotation	过滤器扫描使用注解所标注的那些类，通过expression属性指定要扫描的注释
assignable	过滤器扫描派生于expression属性所指定类型的那些类
aspectj	过滤器扫描与expression属性所指定的AspectJ表达式所匹配的那些类
custom	使用自定义的org.springframework.core.type.TypeFliter实现类，该类由expression属性指定
regex	过滤器扫描类的名称与expression属性所指定正则表示式所匹配的那些类

 2、不使用XML配置,使用java类，仅仅只是换了一种表现形式

直接新建 org.example.config.SpringConfig

@Configuration
@ComponentScan("org.example")
@PropertySource("classpath:jdbc.properties") //多文件使用数组格式，不允许使用*
public class SpringConfig {

    @Value("${jdbc.driver}")
    private String driver;
    //管理第三方Bean
    //1 定义1个要管理的对象，方法名就是Bean的ID
    //2 添加@Bean 表示当前方式返回值是一个Bean
    @Bean
    public DataSource dataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl("");
        return  ds;
    }
}

@Repository("bookDao")
//@Scope("prototype")
public class BookDaoImpl implements BookDao {
    @Override
    public void save() {
        System.out.println("BookDaoImpl save..");
    }
    @PostConstruct //初始化执行方法
    public void Init(){
        System.out.println("BookDaoImpl Init..");
    }
}

@Service("bookSvr")
public class BookServiceImpl implements BookService {
    //自动注入
    @Autowired
    //指定按名称加载，不指定按类型加载
    @Qualifier("bookDao2")
    private BookDao bookDao;

    //值类型
    @Value("hellomc")
    private String name;

    //从属性文件获取，需要先在springConfig中加载资源文件
    // @PropertySource("classpath:jdbc.properties")
    @Value("${test.mc}")
    private String testmc;

    @Override
    public void save() {
        System.out.println("BookServiceImpl name: " + name);
        System.out.println("BookServiceImpl propertiesmc: " + testmc);
        bookDao.save();
    }
}

public class App2 {
    public static void main(String[] args) {

        //读配置类
        ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = app.getBean("bookDao",BookDao.class);
        bookDao.save();

        BookService bookService = app.getBean("bookSvr", BookService.class);
        bookService.save();
    }
}

通过@Component将切面定义为Spring管理Bean。 

@Repository：

@Component扩展，被@Repository注解的POJO类表示DAO层实现，从而见到该注解就想到DAO层实现，使用方式和@Component相同；

@Service：

@Component扩展，被@Service注解的POJO类表示Service层实现，从而见到该注解就想到Service层实现，使用方式和@Component相同；

@Controller：

@Component扩展，被@Controller注解的类表示Web层实现，从而见到该注解就想到Web层实现，使用方式和@Component相同；

在使用Spring代理时，默认只有在public可见度的方法的@Transactional 注解才是有效的，其它可见度（protected、private、包可见）的方法上即使有@Transactional 注解也不会应用这些事务属性的，Spring也不会报错，如果你非要使用非公共方法注解事务管理的话，可考虑使用AspectJ。

Spring声明式事务实现其实就是Spring AOP+线程绑定实现，利用AOP实现开启和关闭事务，利用线程绑定（ThreadLocal）实现跨越多个方法实现事务传播。

@Configuration注解是声明一个IOC容器，把所有标记了@Bean注解的类注入到IOC容器中去。

就相当于xml配置文件：

<!--beans就是@Configuration注解 -->
<beans>
    <!--bean 就是一个个@Component注解声明的类 -->
    <bean></bean>
    <bean></bean>
    <bean></bean>
</beans>

XML与注解比较