Died line

35
文章
9
分类
30
标签

Spring-bean配置

####xml bean的自动装配
需要做的是在的autowire属性里指定自动装配的模式

  • byType 根据类型自动装配 如果IOC容器中存在多个于目标bean类型一致的bean,这种情况下Spring无法判断，所以无法执行自动装配
  • byName 根据名称自动装配 必须将目标bean的名称和属性名设置的完全相同
  • conStructor 通过构造器自动装配 当bean中存在多个构造器时，这种方式会很复杂，所以不推荐使用

xml文件

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="address" class="com.diedline.spring.beans.autowire.Address" p:city="杭州" p:street="HuiLong"></bean>
    <bean id="car" class="com.diedline.spring.beans.autowire.Car" p:brand="Audi" p:price="300000"></bean>
    <!-- 可以使用autowire 属性指定自动装配的方式，
    byName 根据bean的名字和当前bean的setter风格进行自动装配 若有匹配则自动装配没有则不装配
    byType 根据当前bean的类型和当前bean的属性进行自动装配  byType有一个问题当存在多个匹配的类型时无法装配上因为不是唯一
     -->
    <bean id="person" class="com.diedline.spring.beans.autowire.Person" p:name="Tom" autowire="byType"></bean>
</beans>

####bean的继承

使用 parent来继承上级的bean 如果存在不需要class的bean 那么那个bean一定是模板bean
abstract=”true” 只能被其他的bean继承如果使用depends-on 就代表必须这个bean必须存在这个依赖的对象。

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--使用abstract 为true的bean无法实例化 只能被继承
     当abstract 为true时甚至不需要获取类名
     -->
    <bean id="address" p:city="北京" p:street="五道口" abstract="true"></bean>
    <!-- 使用bean的parent 属性继承上面的bean的配置 -->
    <bean id="address2"   class="com.diedline.spring.beans.autowire.Address" p:city="北京" parent="address"
    p:street="DaZhongSi"></bean>

    <bean id="car" class="com.diedline.spring.beans.autowire.Car" p:brand="AuDi" p:price="3000000"></bean>

    <!-- 要求在配置person这个bean的时候必须依赖于car 这个bean -->
    <bean id="person" class="com.diedline.spring.beans.autowire.Person" p:name="Tom" p:address-ref="address2"
    depends-on="car">

    </bean>

</beans>

####bean的作用域
默认bean是单例模式的每次初始化一个对象都是同一个对象 因为在ioc容器创建的时候对象就创建了
你可以使用scope=”prototype” 来将每次创建对象的时候变成实例化的时候，每次实例化都创建一个新的对象

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 使用bean 的scope属性来配置bean的作用域
        默认是singleton  容器初始化值创建bean实例 在容器的生命周期内只创建这一个bean 即单例的
        prototype 原型的 容器初始化时不创建bean的实例而在每次请求时都创建一个新的bean实例并返回
    -->
    <bean id="car" class="com.diedline.spring.beans.autowire.Car" p:brand="AuDi"
          scope="prototype" p:price="300000"></bean>
</beans>

####使用外部配置文件结合bean加载配置数据源
注意需要引入c3p0包

xml

<?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-4.2.xsd
">
    <!--
        导入属性文件
    -->
    <context:property-placeholder location="classpath:db.properties"/>

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${user}"></property>
        <property name="password" value="${password}"></property>
        <property name="driverClass" value="${driverClass}"></property>
        <property name="jdbcUrl" value="${jdbcUrl}"></property>
    </bean>
</beans>

db.properties 文件 

user=root
password=dljyxx225
driverClass=com.mysql.cj.jdbc.Driver
jdbcUrl=jdbc:mysql://localhost:3306/myfirstdb?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false

####Spring SPEL学习

使用spel 语法 格式 #｛｝ 它能为bean赋字面值，引用其他bean 引用其他bean的属性使用java类中的静态方法 还能使用三元运算符进行操作 

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--使用spel为属性赋一个字面值-->
    <bean id="address" class="com.diedline.spring.beans.spel.Address"
          p:street="WuDaoKou" p:city="#{'北京'}"></bean>

    <!--使用spel 引用类的静态方法 -->
    <bean id="car" class="com.diedline.spring.beans.spel.Car" p:price="300000"
    p:brand="AoDi" p:tyrePerimeter="#{T(java.lang.Math).PI * 80}"></bean>

    <!--使用spel来引用 其他bean 和其他bean的属性 还有三元运算符 -->
    <bean id="person" class="com.diedline.spring.beans.spel.Person" p:name="张三" p:car="#{car}" p:city="#{address.city}"
    p:info="#{car.price >300000 ?  '金领':'白领'}"

    ></bean>
</beans>

####配置bean的后置处理器
xml

<?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:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="car" class="com.diedline.spring.beans.cycle.Car" p:brand="AuDi" init-method="init" destroy-method="destroy"></bean>

    <!--
            配置bean的后置处理器 不需要配置id bean自动识别 是一个beanPostProcessor 
        需要实现BeanPostProcessor接口 并具体提供两个方法的实现
        postProcessBeforeInitialization(Object o, String s)： init Method 之前被调用
        postProcessAfterInitialization(Object o, String s)  init Method 之后被调用
        bean(o) 实例本身
        beanName(s)    IOC容器配置bean的名字
        返回值  是实际上返回给用户的bean，注意  可以在以上两个方法中修改返回的bean甚至返回一个新的bean
    -->
    <bean class="com.diedline.spring.beans.cycle.MyBeanProcessor"></bean>
</beans>

实现的BeanPostProcessor接口

package com.diedline.spring.beans.cycle;

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

public class MyBeanProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object o, String s) throws BeansException {
        System.out.println("postProcessBeforeInitialization"+ o + "," + s);
        return o;
    }

    @Override
    public Object postProcessAfterInitialization(Object o, String s) throws BeansException {
        System.out.println("postProcessAfterInitialization" + o + ","+ s);
        Car car = new Car();
        car.setBrand("Ford");
        return car;
    }
}

####使用工厂方法配置bean

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
        <!-- 通过静态方法来配置bean 注意不是配置静态工厂方法实例，而是配置bean实例 -->
        <!--
            class属性：指向静态方法的全类名
            factory-method属性： 指向静态方法工厂方法的名字
            constructor-arg属性：如果工厂方法需要传入参数 则使用constructor-arg配置
            -->
    <bean id="car" class="com.diedline.spring.beans.factory.StaticCarFactory" factory-method="getCar">
        <constructor-arg value="AuDi"></constructor-arg>
    </bean>
    <!-- 配置工厂的实例-->
    <bean id="carFactory" class="com.diedline.spring.beans.factory.InstanceCarFactory">
    </bean>
    <!--通过实例工厂方法来配置bean -->
    <bean id="car2" factory-bean="carFactory" factory-method="getCar">
        <constructor-arg>
            <value>AuDi</value>
        </constructor-arg>
    </bean>
</beans>

InstanceCarFactory

package com.diedline.spring.beans.factory;

import java.util.HashMap;
import java.util.Map;

/**
 * 实例工厂的方法： 即先需要创建工厂本身再创建工厂方法来返回bean的实例
 *
 */
public class InstanceCarFactory {
    private Map<String,Car> cars = null;

    public InstanceCarFactory() {
        cars = new HashMap<>();
        cars.put("AuDi",new Car("Audi",300000));
        cars.put("Ford",new Car("Ford",400000));
    }
    public Car getCar(String brand){
        return cars.get(brand);
    }
}

StaticCarFactory 

package com.diedline.spring.beans.factory;

import java.util.HashMap;
import java.util.Map;

/**
 * 静态工厂方法：直接调用某一个类的静态方法就可以返回bean的实例
 *
 */
public class StaticCarFactory {

    private static Map<String, Car> cars = new HashMap<>();
    static {
        cars.put("AuDi",new Car("AuDi",300000));
        cars.put("Ford",new Car("AuDi",400000));
    }

    public static Car getCar(String name){

        return cars.get(name);
    }
}

####实现自定义factorybean（需要先去实现FactoryBean接口）

package com.diedline.spring.beans.factorybean;

import org.springframework.beans.factory.FactoryBean;

//自定义factorybean需要实现 FactoryBean接口
public class CarFactoryBean implements FactoryBean<Car> {
    private String brand;

    public void setBrand(String brand) {
        this.brand = brand;
    }

    //返回bean的对象
    @Override
    public Car getObject() throws Exception {
        return new Car(brand,500000);
    }


    /**
     * 返回bean的类型
     * @return
     */
    @Override
    public Class<?> getObjectType() {
        return Car.class;
    }


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

xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--
        通过factoryBean来配置bean的实例
        class 指向factoryBean的全类名
        property 配置的是factoryBean的属性 但实际返回的实例却是factorybean类的getObj 方法返回的实例
    -->
    <bean id="car" class="com.diedline.spring.beans.factorybean.CarFactoryBean">
        <property name="brand" value="BMN"></property>
    </bean>
</beans>

####通过注解来配置bean

@Repository 持久层

@Controller 表现层

@Service 业务层

xml文件
通过xml文件配置指定的Spring加载的资源

<?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">
    <!-- 指定SpringIOC容器扫描的包 -->
    <!-- 可以通过resource-pattern 指定扫描的资源  -->
    <!--
    <context:component-scan base-package="com.diedline.spring.beans.annotation" resource-pattern="repository/*.class"></context:component-scan>
    -->

    <!-- context:exclude-filter 子节点指定排除那些指定表达式的组件
        使用assignable 是指定排除的具体的接口
    -->
    <!-- context:include-filter 子节点指定包含哪些表达式的组件 需要使用use-default-filters来配合 -->
    <context:component-scan base-package="com.diedline.spring.beans.annotation"
    >
        <!--
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"></context:exclude-filter>
        -->
        <!--
        <context:include-filter type="annotation" expression="org.springframework.stereotype.Repository"></context:include-filter>
        -->
        <!--
        <context:exclude-filter type="assignable" expression="com.diedline.spring.beans.annotation.repository.UserRepository"></context:exclude-filter>
        -->
        <!--
        <context:include-filter type="assignable" expression="com.diedline.spring.beans.annotation.repository.UserRepository"></context:include-filter>
        -->
    </context:component-scan>

</beans>

UserController.class

package com.diedline.spring.beans.annotation.controller;

import com.diedline.spring.beans.annotation.service.UserService;
import org.springframework.stereotype.Controller;

/**
 * 模拟表现层
 */
@Controller
public class UserController {
    private UserService userService;

    public void execute(){
        System.out.println("UserController Execute ......");
        userService.add();
    }
}

UserRepository interface

package com.diedline.spring.beans.annotation.repository;

public interface UserRepository {
    void save();
}

UserRepositoryimpl.class

package com.diedline.spring.beans.annotation.repository;

import org.springframework.stereotype.Repository;

/**
 * 模拟持久层
 */

@Repository("userRepository")
public class UserRepositoryimpl implements UserRepository {
    @Override
    public void save() {
        System.out.println("UserRepositoryimpl....");
    }
}

UserService.class

package com.diedline.spring.beans.annotation.service;

import com.diedline.spring.beans.annotation.repository.UserRepository;
import org.springframework.stereotype.Service;

/**
 * 模拟业务层
 */
@Service
public class UserService {
    private UserRepository  userRepository;
    public void add(){
        System.out.println("User Service add .....");
        userRepository.save();
    }
}

TestObject

package com.diedline.spring.beans.annotation;

import org.springframework.stereotype.Component;

@Component
public class TestObject {
}

Main.java

package com.diedline.spring.beans.annotation;

import com.diedline.spring.beans.annotation.controller.UserController;
import com.diedline.spring.beans.annotation.repository.UserRepository;
import com.diedline.spring.beans.annotation.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans-annotation.xml");
//        TestObject testObject = (TestObject) applicationContext.getBean("testObject");
//        System.out.println(testObject);

        UserController userController = (UserController) applicationContext.getBean("userController");
        System.out.println(userController);
        userController.execute();
//        UserService userService = (UserService) applicationContext.getBean("userService");
//        System.out.println(userService);
//
//        UserRepository userRepository = (UserRepository)applicationContext.getBean("userRepository");
//        System.out.println(userRepository);

    }
}

使用AutoWired实现自动装配

如在属性上面自动装配

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    public void execute(){
        System.out.println("UserController Execute ......");
        userService.add();
    }
}

在方法上面自动装配（因为testObject为空对象所以指定required=false）

@Repository
public class UserRepositoryimpl implements UserRepository {
    private TestObject testObject;
    @Autowired(required=false)
    public void setTestObject(TestObject testObject) {
        this.testObject = testObject;
    }

    @Override
    public void save() {
        System.out.println("UserRepositoryimpl....");
    }
}

值得注意的是如果存在多个相同的bean时并且自动装配会抛异常
一种解决方式是在自动引用的地方写上你要引用的bean的名字
另一种是在自动引用的下面使用@Qualifier写上你要引用的bean的名字也可以将@Qualifier写在set方法输入参数之前也是一样的。

//这样也OK
    @Autowired
    @Qualifier("userRepositoryimpl")
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

泛型依赖自动注入

定义一个BaseRepository类

package com.diedline.spring.beans.generic.di;

public class BaseRepository<T> {
}

BaseService类在使用AutoWired自动装配的时候会自动使用定义的BaseRepository中自带的泛型

package com.diedline.spring.beans.generic.di;

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


public class BaseService<T> {
    @Autowired
    protected BaseRepository  repository;

    public void add(){
        System.out.println("add.....");
        System.out.println(repository);
    }
}