1.Spring 的依赖注入

1.1 什么是spring

它是一个轻量级和IOC(DI)和AOP的容器框架

IOC：控制反转以前是我们自己new对象现在创建bean的方式，是交给spring帮我们创建

DI：依赖注入 spring它是容器框架，是一个bean(装对象的)容器框架，spring帮我创建好对象之后，在把我们创建好的对象注入到相应的类里面这个过程

AOP: 面向切面的编程

AOP使用场景：

事务管理

日志管理

性能控制

1.2 spring的DI依赖注入

1.2.1 set方式注入(最开始)

以前

applicationContext.xml配置通过全限定名找到这个类给这个类创建好对象通过set方法传进去
< bean id=“userService” class="…UserServiceImpl">

    
  
UserController{

	private UserService userService;
// 默认就是 通过set属性传值 
	void setUserService(UserService userService){

    		this.userServicer = userService;
     }
}

1.2.2构造器注入

index索引注入

 注意value 值对应类型   索引从0开始
<constructor-arg index="0" value="123"></constructor-arg>

name 参数名字注入

  
<constructor-arg name="id" value="456"></constructor-arg>

type类型注入

若是有多个相同的类型 依次添加值即可
 <constructor-arg type="java.lang.Long" value="111"></constructor-arg>

1.2.3 类里面属性注入

属性注入：  最常用就是基本类型和引用类型注入
 //基本数据类型注入
   <property name="id" value="111"></property>
   <property name="name" value="康康"></property>
// ref  引用一个对象    
   <property name="hellobean" ref="hb"></property>
   <property name="hellobean">
     //直接注入一个对象
          <bean class="xxxx"></bean>
    </property>

 <!-- 数组注入方式1  属性注入底层还是使用的set方法-->
<property name="strings" value="A,B,B,B"></property

                <!-- 数组注入方法二-->
<property name="strings">
<array >
<value>是尼玛 </value>
<value>是我</value>
</array>
</property>
 <!-- 集合注入方法-->
<property name="list">
<list>
    <value>你让我说点啥好</value>
    <value>你让我说点啥好</value>
    <!--创建的对象 每次都是不同的对象-->
    <bean class="_01_di.cn.itsource.HelloBean"></bean>
    <bean class="_01_di.cn.itsource.HelloBean"></bean>
    <!-- 引用的两个地址是一样的 -->
    <ref bean="hello"></ref>
    <ref bean="hello"></ref>
</list>

 <!-- 集合注入方法 set-->
<property name="set">
 <set>
 <value>小胡</value>
 <value>小胡</value>
 // 注入一个bean对象 注入的对象地址都是不同的
      <bean class="_01_di.cn.itsource.HelloBean"></bean>
     <bean class="_01_di.cn.itsource.HelloBean"></bean>
     // 引用的地址是一样的
     <ref bean="hello"></ref>
     <ref bean="hello"></ref>
 </set>


<!-- map传值-->
<property name="hp">
<map>
<entry key="小胡" value="小幸福"></entry>
<entry key="小长" value="陆小凤"></entry>
</map>

</property>


注入properties
// 不支持中文
<property name="prop1">
<value>
driverClassName=com.mysql.jdbc.Driver
username=qiang强
</value>
</property> 
<property name="prop2">
//支持中文
<props>
<prop key="driverClassName">com.mysql.jdbc.Driver</prop>
<prop key="username">qiang强</prop>
</props>
</property>

1.3 XML版本自动注入

可以byName – 按照名称自动注入
或者byType注入 – 按照类型自动注入（默认就是bytype）
根节点beans default-autowire=“byName” 对当前配置文件的所有bean都生效
子节点bean autowire="byType"只对当前bean生效

通常如果我们需要给一个bean注入另一个bean时都是通过set方法或者构造方法进行注入，其实Spring也支持bean的自动注入。在定义bean时我们可以通过bean元素的autowire属性来指定是否需要给当前bean来自动注入其所关联的bean。autowire属性的可选值有四个。

no：默认值。表示不进行自动注入。
- byName：根据名称进行自动注入。如beanA有一个setBeanB()方法，指定autowire=”byname”时Spring将自动在bean容器中寻找名为“beanB”的bean通过setBeanB方法自动注入给beanA。
- byType：根据类型进行自动注入。如beanA有一个setBeanB(BeanB b)方法，指定autowire=”byType”时Spring将自动在bean容器中类型为BeanB的bean通过setBeanB()方法注入给beanA。但是如果此时容器中有两个以上类型为BeanB的bean时就将抛出异常。解决方法若是有两个相同类型的baen的时候可以使用 name来注入
- constructor：等同于byType，只是当指定autowire=”constructor”时表示将通过构造方法根据类型进行自动注入。

xml详解


    <bean id="userController" class="_02_autoxml.cn.itsource.UserController" autowire="byType">
        <!--<property name="userService" ref="service"></property>-->
    </bean>

    <bean id="userDao" class="_02_autoxml.cn.itsource.UserDao"></bean>

    <bean id="userService" class="_02_autoxml.cn.itsource.UserServiceImpl">
       <!-- <property name="userDao" ref="dao"></property>-->
    </bean>

1.4 XML版本注解注入

扫描包路径  扫描注解：
        @Component 普通类上面打的注解(普通仓库), @Repository, @Service,@Controller
<context:component-scan base-package="_03_annoxml.cn.itsource"></context:component-scan>

如果一个接口有两个实现情况下：

       方案一：一个接口有多个实现的情况下面 通过名字去区分
       方案二：通过Resource这个注解
       区别：@Autowired和@Qualifier 都是属于spring的注解 ，
          Resource使用jdk的注解 推荐使用Autowired和Qualifier，可以和spring进行无缝衔接
          autowired默认是根据类型匹配，如果类型匹配不上在根据名字匹配
          而Resource默认根据名字匹配，名字匹配不上就匹配类型

2 Spring里面AOP功能

2.1 什么是springAOP

aop: 面向切面的编程
而AOP的出来并不是要取代OOP(面向对象编程)，它只是作为一个补充的角色过来，来解决一些咱们OOP（面向对象）解决不了(或者说很难解决)的一些代码。
AOP的使用只存在于一些特定的场合(具有横切逻辑的应用场合),横切逻辑这个解释可能比较抽象，咱们说得再具体一点，AOP可以用于事务管理，日志管理，性能监测等地方。

2.2aop的实现

aop底层使用代理模式实现

jdk代理模式 --有接口情况下

cglib动态代理 --没有接口情况下

2.3 springaop配置方式

xml版本的配置

// 扫描主键
<context:component-scan base-package="_04_aopxml"></context:component-scan>
    <aop:config>
       // 在哪里切入
        <aop:pointcut id="pointcut" expression="execution(* _04_aopxml.I*Service.*(..))"></aop:pointcut>
        <!--配置通知  引用事务管理--> 
        <aop:aspect ref="txManager">
            <!-- 前置通知-->
            <!--<aop:before method="begin" pointcut-ref="pointcut"></aop:before>
            &lt;!&ndash; 后置通知&ndash;&gt;
            <aop:after-returning method="commit" pointcut-ref="pointcut"></aop:after-returning>
            &lt;!&ndash; 最终通知&ndash;&gt;
            <aop:after method="close" pointcut-ref="pointcut"></aop:after>
            &lt;!&ndash; 异常通知&ndash;&gt;
            <aop:after-throwing method="rollback" throwing="e" pointcut-ref="pointcut"></aop:after-throwing>-->
            <!-- 环绕通知-->
            <aop:around method="around" pointcut-ref="pointcut"></aop:around>
        </aop:aspect>
    </aop:config>
    <bean id="txManager" class="_04_aopxml.TxManager"></bean>

注解版本配置

@Component
@Aspect
public class TxManager {

   // 在哪里切入 执行
    @Pointcut("execution(* _05_aopanno.I*Service.*(..))")
    //切入点
    public void pointcut(){}

    //<aop:before method="begin" pointcut-ref="pointcut"></aop:before>
    //@Before("pointcut()")
    public void begin(){
        System.out.println("开启事务");
    }

  ///  @After("pointcut()")
    public void commit(){
        System.out.println("提交事务");
    }
    //@AfterReturning("pointcut()")
    public void close(){
        System.out.println("关闭");
    }
    //所有的异常的父类
   // @AfterThrowing(value = "pointcut()",throwing = "e")
    public void rollback(Throwable e){
        System.out.println("回滚事务"+e.getMessage());
    }

    //环绕通知
    @Around("pointcut()")
    public void around(ProceedingJoinPoint joinPoint){
        try {
            begin();
            //调用方法
            joinPoint.proceed();
            commit();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }finally{
            close();
        }
    }
}

3 Bean的创建方式

以前模式：通过new 对象方式创建

spring方式：spring帮我们创建bean 。–创建bean的方式

3.1 Bean创建方式一

通过无参数的构造方法来创建bean --最常用方式

配置

<bean id="mybean" class="_06_bean.Mybean"></bean>

3.2 Bean创建方式二

FactoryBean 工厂对象

 //实现 FactoryBean
public class MybeanFactoryBean implements FactoryBean<Mybean> {
    //返回对象
    public Mybean getObject() throws Exception {
        return new Mybean("xxx", "18");
    }
   
    public Class<?> getObjectType() {
        return Mybean.class;
    }
    //是否单例
    public boolean isSingleton() {
        return true;
    }
}

3.3 Bean创建方式三

通过类里面定义静态方法来获取bean

public class MybeanFactory {

    public static Mybean getBean(){
        return new Mybean();
    }
}

<bean class="_06_bean.MybeanFactory" factory-method="getBean"></bean>

3.4 Bean创建方式四

public class MybeanFactory1 {
    //普通方式
    public  Mybean getBean1(){
        return new Mybean();
    }
}

<bean class="_06_bean.MybeanFactory1" id="mybeanFactory1"></bean>
    <bean factory-bean="mybeanFactory1" factory-method="getBean1"></bean>

public class MybeanFactory1 {
    //普通方式
    public  Mybean getBean1(){
        return new Mybean();
    }
}

<bean class="_06_bean.MybeanFactory1" id="mybeanFactory1"></bean>
    <bean factory-bean="mybeanFactory1" factory-method="getBean1"></bean>

羡慕班长

发布了23 篇原创文章 · 获赞 2 · 访问量 937

私信关注

bean创建的四种方式 springAOP的两种配置方式 xml版本自动注入bean 全注解自动注入对象 bean对象属性注入的三种方式 spring依赖注入