Spring 基础回顾

1、IOC理论推导

User user = context.getBean("user",User.class);
User user = (User)context.getBean("user");
两种强转方式

在我们之前的业务中,用户的需求可能会影响我们原来的代码,我们需要根据用户的需求去修改源代码!如果程序代码量十分大,修改一次的成本代价十分昂贵!

在这里插入图片描述

我们使用一个Set接口实现.已经发生了革命性的变化!

private  UserDao userDao;
//利用set进行动态实现值得注入!
public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

之前,程序是主动创建对象!控制权在程序员手上
使用了set注入后,程序不再具有主动性,而是变成了被动的接收对象

这种思想,从本质上解决了问题,程序员不用再去管理对象的创建了.系统的耦合性大大降低~ 可以更加专注在业务的实现上!

1、1编写相关代码

1.编写一个Hello实体类.都装入spring配置文件中

public class Hello {
    private String name;

    public String getName() {
        return name;
    }

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

    public void show(){
        System.out.println("Hello"+name);
    }
}

2.编写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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <!--bean就是java对象,由Spring创建和管理-->
   <bean id="hello" class="ceshi.Hello" >
        <property name="name" value="测试"/>
   </bean>
</beans>

3.测试.所有的bean都需要通过容器去取

   public static void main(String[] args) {
        //解析beanx.xml文件,生成管理相应的bean对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //getBean : 参数即为spring配置文件中的bean的id,bean拿出来就是一个对象,然后去调用就好了
        Hello hello = (Hello) context.getBean("hello");
        hello.show();
    }

4.思考问题

Hello对象是谁创建的?

hello对象是由Spring创建的
Hello对象的属性是怎么设置的?

hello对象的属性是由Spring容器设置的

这个过程就叫控制反转:

控制:谁来控制对象的创建,传统应用程序的对象是由程序本身创建的,使用Spring后,对象的创建由spring来创建

反转:程序本身不创建对象,而变成被动的接收对象

依赖注入:就是利用set方法来进行注入的

IOC是一种编程思想,由主动地变成变成被动的接收.

到了现在.不用再去更改程序中的代码了.要实现不同的操作,只需要在xml配置文件中进行修改,所谓的IOC,一句话描述就是:对象由Spring来创建,管理,装配!

2、IOC本质

控制反转IOC,是一种设计思想,ID(依赖注入)是实现IOC的一种方法,没有IOC的程序中,我们使用面向对象编程,对象的创建于对象间的依赖关系完全硬编码在程序中,对象的创建有程序自己控制,控制的反转后,将对象的创建转移给第三方,获得依赖对象的方式反转了

控制反转是一种通过描述(XML或注解)并通过第三方去生产或获取特定对象的方式,在Spring中实现控制反转的是IOC容器,其实现方法是依赖注入(Dependency Injection,DI)

使用配置实现

 
    <bean id="hello" class="com.zjt.hello">
         <property name="str" value="我是一个值"/>
    </bean>
  <!--使用Spring来创建对象,在Spring这些都称为Bean
        id = 变量名
        class = new 的对象();
        property 相当于给对象中的属性设置一个值!
        bean就是java对象 , 由Spring创建和管理
		ref:引用Spring容器中创建好的对象
		value:具体的值,基本数据类型!-->

3、IOC创建对象的方式

使用无参构造器创建对象,默认!

假设使用有参构造器

<!--第一种,下标赋值!-->
 <bean id="user" class="com.zjt.entity.User">
      <constructor-arg index="0" value="下标赋值"/>
 </bean>

<!--第二种,类型赋值,不建议使用!-->
  <bean id="user" class="com.zjt.entity.User">
       <constructor-arg type="java.lang.String" value="类型赋值"/>
  </bean>

<!--第三种,通过参数名赋值!-->
  <bean id="user" class="com.zjt.entity.User">
       <constructor-arg name="name" value="参数名赋值"/>
  </bean>

总结:在配置文件加载的时候,容器中管理的对象就已经初始化了

4、Spring配置

Bean的配置

<!--
  id:bean的唯一标识符,相当于对象名
  clas:bean对象所对应的全限定名:包名+类型
  name:是别名,可以同时取多个名字
 -->
  <bean id="user" class="com.zjt.entity.User" name="n1,n2">
      <property name="name" value="测试"/>
  </bean>

import

这个import,一般用于团队开发使用,他可以将多个配置文件,导入合并为一个总的applicationContext.xml

<import resource="beans1.xml"/>
<import resource="beans2.xml"/>

5、依赖注入

Set方式注入(重要)
- 依赖:bean对象的创建依赖于容器!
- 注入:bean对象中的所有属性,由容器来注入!

<!--bean就是java对象 , 由Spring创建和管理-->
<bean id="address" class="com.zjt.pojo.Address">
    <property name="address" value="ZJT"/>
</bean>

<bean id="student" class="com.zjt.pojo.Student">
    <!--第一种,普通注入.value-->
    <property name="name" value="打印"/>
    <!--第二种,Bean注入,ref-->
    <property name="address" ref="address"/>
    <!--数组注入,array-->
    <property name="books">
        <array>
            <value>红楼梦</value>
            <value>水浒传</value>
            <value>西游记</value>
            <value>三国演义</value>
        </array>
    </property>
    <!--list注入,list-->
    <property name="hobbys">
        <list>
            <value>听歌</value>
            <value>看电影</value>
            <value>打游戏</value>
            <value>骑行</value>
        </list>
    </property>
    <!--map注入,map-entry-->
    <property name="card">
        <map>
            <entry key="身份证" value="123456789"/>
            <entry key="银行卡" value="987654321"/>
        </map>
    </property>
    <!--set注入,set-->
    <property name="games">
        <set>
            <value>LOL</value>
            <value>CF</value>
        </set>
    </property>
    <!--null注入-->
    <property name="wife">
        <null/>
    </property>
    <!--属性 props-->
    <property name="info">
        <props>
            <prop key="username">试试</prop>
            <prop key="passwd">123</prop>
        </props>
    </property>
</bean>

扩展注入

xmlns:c="http://www.springframework.org/schema/c"
xmlns:p="http://www.springframework.org/schema/p"
<!--p命名空间注入,可以直接注入属性的值:property-->
<bean id="user" class="com.zjt.pojo.User" p:name="我是name" p:age="18" />
<!--c命名空间注入,使用构造器进行注入(赋值的属性是有参构造器传入的属性):constructor-args-->
<bean id="user1" class="com.zjt.pojo.User" c:age="18" c:name="ZJT" />

6、Bean的作用域

在这里插入图片描述

单例模式(Spring默认机制)

<bean id="user" class="com.zjt.pojo.User" p:name="我是单例" scope="singleton"/>

原型模式:每次从容器中get的时候,都会产生一个新对象!

<bean id="user" class="com.zjt.pojo.User" p:name="我是原型模式" scope="prototype"/>

其余的request、session、application这个只能在web开发使用

7、Bean的自动装配

自动装配是Spring满足bean依赖的一种方式!
Spring会在上下文中自动寻找,并自动给bean装配属性!

在Spring中有三种装配的方式

在xml中显示的配置
在java中显示的配置
隐式的自动装配bean(重要)

7.1、测试

byName:会自动在容器上下文中查找,和自己对象set方法后面的值对象的 bean id
byType:会自动在容器上下文中查找,和自己对象属性类型相同的bean,需要保证属性类型全局唯一,可以省略bean的id
<bean id="people" class="com.zjt.pojo.People" autowire="byName">
    <property name="name" value="zjt"/>
</bean>

小结:

byName:需要保证所有bean的id唯一,并且这个bean需要和自动注入的属性的set方法的值一致!
byType:需要保证所有bean的class唯一,并且这个bean需要和自动注入的属性的类型一致!

7.2、使用注解实现自动装配

导入约束:context约束
配置注解的支持:<context:annotation-config/>

<?xml version="1.0" encoding="UTF-8"?>  
    <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://www.springframework.org/schema/beans"
        xmlns:context="http://www.springframework.org/schema/context"  
  
        xsi:schemaLocation="http://www.springframework.org/schema/beans  
               http://www.springframework.org/schema/beans/spring-beans-3.0.xsd  
               http://www.springframework.org/schema/context  
               http://www.springframework.org/schema/context/spring-context-3.0.xsd  
  		<!-- 开启注解的支持 必须的 -->
        <context:annotation-config/>
    </beans>

@Autowired:直接在属性上使用即可!使用它可以不必生成Set方法,自动装配的属性必须存在IOC容器中,按照byType装配,其次按照byName装配,使用@Qualifier(value=“指定bean id”)配合注入

8、使用注解开发

属性如何注入

@Component
public class User {
    //相当于<property name="name" value="zjt"/>
    @Value("zjt")
    public String name;
}

衍生的注解

@Component(组件)有几个衍生注解,我们在web开发中,会按照mvc三层架构分层!
- dao[@Repository]
- service[@Service]
- controller[@Controller]
  
  这四个注解功能都是一样的,都是代表将某个类注册到Spring中,装配Bean
自动装备注解
- @Autowired:自动装配通过类型,名字,如果@Autowired不能唯一自动装配上属性,则需要通过@Qualifier(value=“指定bean id”)配合注入
- @Nullable:字段标记了这个注解,说明这个字段可以为null
- @Resource:自动装配通过名字.类型.(java自带的,建议使用@Autowired)
作用域

@Scope(“prototype”)
小结

xml与注解:
- xml:更加万能,适用于任何情景,维护简单方便!
- 注解:不是自己的类使用不了,维护相对复杂!
xml与注解最佳实践:
- xml用来管理bean;
- 注解只负责完成属性的注入;(@Value)
- 我们在使用的过程中,只需要注意一个问题:必须开启注解支持
```

<context:component-scan base-package="com.zjt"/>
<context:annotation-config/>
```

9、使用Java的方式配置Spring

现在要完全不适用Spring的xml配置了,全权交给Java来做!

JavaConfig是Spring的一个字项目,在Spring4之后,它成为了一个核心功能!

实体类

//注解的意思为,这个类被Spring接管了,注册到容器中
@Component
public class User {
    private String name;

    @Value("zjt")//属性注入值
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
}

配置文件

package com.zjt.config;

import com.zjt.pojo.User;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

//这个也会被Spring容器托管,注册到容器中,因为他就是@Component
//@Configuration代表这是一个配置类,就和beanx.xml一样的
@Configuration
@ComponentScan("com.zjt.pojo")
//引入其他配置类
@Import(ZjtConfig2.class)
public class zjtConfig {
    //注册一个bean,相当于bean标签,方法名相当于bean标签中的id
    //返回值相当于bean标签中的class属性
    @Bean
    public User user(){
        return new User();//就是返回要注入到bean的对象!
    }
}

测试类

public class MyTest {
    public static void main(String[] args) {
        //如果完全使用了配置类,我们只能通过 AnnotationConfig 上下文来获取容器,通过配置类的class对象加载!
        ApplicationContext context = new AnnotationConfigApplicationContext(zjtConfig.class);
        User user = context.getBean("user",User.class);
        System.out.println(user.getName());
    }
}

这种纯Java的配置方式,在SpringBoot中随处可见!

10、代理模式

代理模式就是SpringAOP的底层!

代理模式的分类:

动态代理
静态代理

在这里插入图片描述

10.1、静态代理

角色分析:

抽象角色:一般会使用接口或者抽象类来解决
真实角色:被代理的角色,真正要去做事的人
代理角色:代理真实角色,代理真实角色后,我们一般会做一些附属操作
客户:访问代理对象的人!

代码步骤:

1.接口

//租房
public interface Rent {
    public void rent();
}

2.真实角色

//房东
public class Host implements Rent {
    public void rent() {
        System.out.println("房东要出租房子!");
    }
}

3.代理角色

public class Proxy implements Rent {
    Host host = new Host();

    public Proxy() {}
    
    public Proxy(Host host) {
        this.host = host;
    }
    
    public void rent() {
        seeHost();
        host.rent();
        hetong();
        fare();
    }
    //看房
    public void seeHost(){
        System.out.println("中介带你看房");
    }
    //签合同
    public void hetong(){
        System.out.println("签合同");
    }
    //中介费
    public void fare(){
        System.out.println("收中介费");
    }
}

4.客户端访问代理角色

public class Test {
    public static void main(String[] args) {
        //房东要租房子了
        Host host = new Host();
        //代理,中介帮房东租房子,但是代理会有附属操作
        Proxy proxy = new Proxy(host);
        //不用面对房东,直接跟中介租房
        proxy.rent();
    }
}

代理是的好处:

可以使真实角色的操作更加纯粹!不用去专注一些公共业务
公共业务交给代理角色!实现了业务的分工
公共业务发生扩展的时候,方便集中管理

缺点:

一个真实角色就会产生一个代理角色,代码量会翻倍,开发效率会变低

聊聊AOP,面向切面编程

在这里插入图片描述

10.2、动态代理

动态代理和静态代理角色一样
动态代理的类是动态生成的,不是我们直接写好的!
动态代理也分为两大类:基于接口的动态代理,基于类的动态代理
- 基于接口–JDK动态代理[我们在这里使用]
- 基于类的:cglib
- java字节码实现:javasist(JBoss应用服务器使用)

需要了解两个类:Proxy (prɑːksi):代理 InvocationHandler:调用处理程序

动态代理的好处:

可以使真实角色的操作更加纯粹,不用去关注一些公共的业务
公共业务交给代理角色,实现了业务的分工
公共业务发生扩展的时候,方便集中管理
一个动态代理类代理的是一个接口,一般就是对应的一类业务
一个动态代理类可以代理多个类,只要是实现了同一个接口即可

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

//用这个类自动生成代理类
public class ProxyInvo implements InvocationHandler {

    //被代理的接口
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //生成的到代理类
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }

    //处理代理实例 并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //动态代理的本质,就是使用反射机制
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }

    public void log(String msg){
        System.out.println("执行了"+msg+"方法");
    }
}
     //真实角色
    User user = new User();
    //new代理角色
    ProxyInvo pih = new ProxyInvo();
    //设置要代理的对象
    pih.setTarget(user);
    //动态生成代理类
    User proxy = (User)pih.getProxy();
    proxy.delete();

11、AOP

AOP(Aspect Oriented Programming),面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。”AOP是Spring框架中的一个重要的内容,利用AOP可以对业务逻辑的各个部分进行隔离,从而使得业务逻辑各部分之间的耦合度降低,提高程序的可重用性,同时提高了开发的效率

11.1、使用Spring实现Aop

使用AOP,需要导入一个依赖包!

 <dependency>
     <groupId>org.aspectj</groupId>
     <artifactId>aspectjweaver</artifactId>
     <version>1.9.2</version>
</dependency>

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

//使用注解实现AOP
@Aspect//表示这个类是一个切面
public class AnnotaitionPointCut {
    //execution(执行)
    @Before("execution(* com.zjt.diy.AnnotaitionPointCut.*(..))")
    public void before(){
        System.out.println("前置通知=========");
    }
    @After("execution(* com.zjt.diy.AnnotaitionPointCut.*(..))")
    public void after(){
        System.out.println("后置通知=========");
    }
    //在环绕增强中,我们可以给定一个参数,代表我们要获取处理切入的点
    @Around("execution(* com.zjt.diy.AnnotaitionPointCut.*(..))")
    public void around(ProceedingJoinPoint jp){
        System.out.println("环绕前");
        System.out.println("环绕后");
    }

声明式事务

在这里插入图片描述

1、IOC理论推导

1、1编写相关代码

2、IOC本质

3、IOC创建对象的方式

4、Spring配置

5、依赖注入

6、Bean的作用域

7、Bean的自动装配

7.1、测试

7.2、使用注解实现自动装配

8、使用注解开发

9、使用Java的方式配置Spring

10、代理模式

10.1、静态代理

10.2、动态代理

11、AOP

11.1、使用Spring实现Aop

猜你喜欢