学习Spring必须了解的DI注入------zjp

第一节 DI依赖注入

[1]为什么使用DI(依赖注入)

作用:给对象中的全局属性或者对象进行赋值的操作

[2]利用DI进行解决

  1. 英文全称(Dependency Injection)
  2. 中文名称:依赖注入
    2.1 依赖:一个类在另一个类中作为全局属性时
    2.2 注入:通过外部给自己属性(或其他内容)进行赋值

3. 类与类之间的关系:

3.1 继承 实现 依赖 关联 聚合 组合
3.7 关系强度:组合 > 聚合 > 关联 > 依赖

4.DI的意义

4.1 解除类与类之间高耦合性,给对象中全局对象赋值的操作

5.为什么称DI和IoC是同一个事情.

5.1 Spring帮助创建对象的过程叫做IoC,创建对象时给对象中全局对象赋值叫做DI,所以认为IoC和DI是同一个事情.

第二节 DI注入的三种方式

[1]有参构造

[1]有参构造
 <!--【A】使用有参构造进行值的注入-->
 <!--
     value  和 ref的使用场景
     如果给基本数据类型+String  注入值的时候使用 value
     如果给对象注入值的时候  使用 ref
 -->
 <bean id="cla" class="com.test.spring01.Clazz">
     <constructor-arg name="cno" value="1"></constructor-arg>
     <constructor-arg name="cname" value="501java"></constructor-arg>
 </bean>

<bean id="stu" class="com.test.spring01.Student" >

     <constructor-arg name="age" value="18"></constructor-arg>

     <constructor-arg name="name" value="zs"></constructor-arg>

     <constructor-arg name="sex" value="男"></constructor-arg>

     <constructor-arg name="clazz" ref="cla"></constructor-arg>
 </bean>

[2] SET方法

<!--【B】使用set方法进行值的注入-->

<bean id="stu" class="com.test.spring01.Student">
    
    <property name="sex" value="男"></property>

    <property name="age" value="18"></property>

    <property name="name"  value="zs"></property>

    <property name="clazz" ref="cla"></property>
</bean>

[3] 自动注入

<!--【C】自动注入
     autowire的可选择值
      *底层调用调用的都是set方法
     byName:查找方式  整个配置文件中查询【bean标签的ID名称】和【注入实体类中的属性名】一致的话,就完成自动注入
    byType:查找方式  整个配置文件中查询【bean标签类型】和【注入实体类中的属性类型】一致的话,就完成自动注入
     *底层走的是构造器
    constructor:首先根据bena 标签的ID名称进行匹配,如果没有对应的值,再根据bean的类型进行匹配
-->
<bean id="stu" class="com.test.spring01.Student" autowire="constructor"></bean>

第三节 其他值注入

public class User {

      private    String []   arr;

      private List<String>   list;

      private Set<String>  set;

      private Map<String ,String>  map;

<!--特殊值的注入-->

 <bean id="user" class="com.test.spring02.User">
     <!--给数组进行值的注入-->
     <property name="arr">

         <array>
             <value>A</value>
             <value>B</value>
             <value>C</value>
         </array>

     </property>
     <!--list集合进行值注入-->
     <property name="list">
         <list>
             <value>A</value>
             <value>B</value>
             <value>C</value>
         </list>
     </property>

     <!--Set集合的赋值-->
     <property name="set">
         <set>
             <value>A</value>
             <value>B</value>
             <value>C</value>
             <value>A</value>
         </set>
     </property>

     <!--Map集合赋值-->
     <property name="map">
         <map>
             <entry>
                 <key><value>A</value></key>
                 <value>test</value>
             </entry>
             <entry>
                 <key><value>B</value></key>
                 <value>test</value>
             </entry>
         </map>
     </property>
 </bean>

第四节 代理模式

[1]设计模式:解决某一类问题的产生

静态代理
代理模式{
动态代理【JDK动态代理、CGLIB动态代理】

[2] 代理模式的角色

A、抽象的类或者接口–定义完成一件怎样的事情
B、代理对象—完成这件事情的对象
C、被代理对象–完成事件背后的隐藏的内容

[3] 代理模式案例

我们找中介租房子
抽象的类或者接口—租房子
被代理对象—房东
代理对象–中介

[4] 代理模式的好处

A、房东安心的做自己的事情即可,不用管理其他的事情
B、房东对象比较的安全
C、增强了代码的扩展性

[5] 静态代理

优点:上述内容
缺点:再中介里面随着房东对象的增多,中介的压力就会月来越大,体现到代码上就是代码越来越臃肿

第五节 JDK动态代理

[1]代码实现

public class MyInvoction implements InvocationHandler {

      private  RentRoom  rm;

    public void setRm(RentRoom rm) {
        this.rm = rm;
    }
    //动态获得代理类对象--中介
    /**
     * 参数一    ClassLoader   类加载器
     * 参数二:  new Class[]{}
     * 参数三: InvocationHandler
     * */
    public  Object  getproxy(){


        return Proxy.newProxyInstance(MyInvoction.class.getClassLoader(),new Class[]{RentRoom.class},this);
    }

    /**
     * 租房的方法
     * **/
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        System.out.println("收取介绍费500元");

        Object invoke = method.invoke(rm, args);

        System.out.println("收取卫生费400元");
        return invoke;
    }
}


[2]理解示意图

在这里插入图片描述

展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 游动-白 设计师: 上身试试
应支付0元
点击重新获取
扫码支付

支付成功即可阅读