SpringIoc

最新推荐文章于 2024-09-13 22:48:29 发布

吴吞

最新推荐文章于 2024-09-13 22:48:29 发布

阅读量65

点赞数

分类专栏： Spring 文章标签： spring mvc java

本文链接：https://blog.csdn.net/qq_41495202/article/details/120377614

版权

Spring 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

一、Spring概念

1 spring是开源的轻量级框架

2 spring核心主要两部分：

（1）aop：面向切面编程，扩展功能不是修改源代码实现

（2）ioc：控制反转，

比如有一个类，在类里面有方法（不是静态的方法），调用类里面的方法，创建类的对象，使用对象调用方法，创建类对象的过程，需要new出来对象
把对象的创建不是通过new方式实现，而是交给spring配置创建类对象

3 spring是一站式框架

spring在javaee三层结构中，每一层都提供不同的解决技术

web层：springMVC
service层：spring的ioc
dao层：spring的jdbcTemplate

4 spring版本

（1）hibernate5.x

（2）spring4.x

二、Spring的ioc操作

1 把对象的创建交给spring进行管理

2 ioc操作两部分：

（1）ioc的配置文件

（2）ioc的注解

三、IOC底层原理

1 ioc底层原理使用技术

（1） xml配置文件

（2）dom4j解决xml

（3）工厂设计模式

（4）反射

四、IOC入门案例

第一步：导入jar包

在这里插入图片描述

第二步：引入schema约束，配置对象创建

 <bean  id="User" class="cn.itcast.ioc.User" ></bean>

第三步：在另一个类中使用

// 加载spring配置文件，根据创建对象
ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");

// 得到配置的对象
Person user=(Person) context.getBean("person2");
System.out.println(user);
user.test();

五、Spring的bean管理（xml方式）

1.Bean的实例化方式

（1）使用类的无参数构造创建（重点）

<bean  id="User" class="cn.itcast.ioc.User" ></bean>

（2）使用静态工厂创建

<bean  id="bean2" class="bean.Bean2Factory" factory-method="getBean2" ></bean>

// 静态方法返回需要创建的Bean2对象
public class Bean2Factory {
    public  static  Bean2 getBean2(){
        return new Bean2();
    }
}

（3）使用实例化工厂创建

<bean  id="bean3Factory" class="bean.Bean3Factory" ></bean>
<bean  id="bean3" class="bean.Bean3Factory" factory-bean="bean3Factory" factory-method="getbean3"></bean>

//工厂类中无静态方法，需要在配置文件中先实例化工厂类
public class Bean3Factory {
    public Bean2 getbean3(){
        return new Bean2();
    }
}

2.Bean标签常用属性

（1）id属性：起名称，id属性值名称任意命名

id属性值，不能包含特殊符号
根据id值得到配置对象

（2）class属性：创建对象所在类的全路径

（3）name属性：功能和id属性一样的，id属性值不能包含特殊符号，但是在name属性值里面可以包含特殊符号

（4）scope属性

singleton：默认值，单例（user1和user2本质相同，地址一样）

User user1=(User) context.getBean("user");
User user2=(User) context.getBean("user");

prototype：多例（两个不同对象）

六、属性注入介绍

1.概念：创建对象时候，向类里面属性里面设置值

2.Spring框架中如何注入

（1）set方法注入（重点）

public class book {

    private String bookname;
    public void setBookname(String bookname) {
        this.bookname = bookname;
    }
    
    public void demobook(){
        System.out.println("book    "+bookname);
    }
}

<!-- 使用set方法注入属性,nmae是属性名称，value是需要注入的属性值-->
<bean id="book"  class="Property.book">
    <property name="bookname" value="吴文杰book"></property>
</bean>

注入对象类型属性（重点）

首先配置生成需要注入的对象，然后使用ref属性将其注入到目标对象中

<bean id="userdao" class="cn.itcast.ioc.UserDao"></bean>

<bean id="userservice" class="cn.itcast.ioc.UserService">
    <!-- name:service类里的属性名称 ref：dao配置bean标签中id值
         name是UserService中待注入的属性名称，ref是配置生成对象的id
         UserService中需要有UserDao的set方法-->
    <property name="userDao" ref="userdao"></property>
</bean>

注入复杂类型属性

<bean id="person2" class="Property.Person">
    <property name="arrs">
        <list>
            <value>小王</value>
            <value>小五</value>
            <value>小巴</value>
        </list>
    </property>
    <property name="list">
        <list>
        <value>赵</value>
            <value>孙</value>
            <value>钱</value>
        </list>
    </property>
    <property name="map">
        <map>
            <entry key="aa" value="wu"></entry>
            <entry key="bb" value="wu2"></entry>
            <entry key="cc" value="wu3"></entry>
        </map>
    </property>
    <property name="properties">
        <props>
            <prop key="driverclass">com.jsjksdlj</prop>
            <prop key="usernmae">root</prop>
        </props>
    </property>
</bean>

（2）使用有参数构造注入属性

<!--有参构造属性注入 -->
<bean id="demo1" class="Property.PropertyDemo1">
    <constructor-arg name="username" value="吴文杰"></constructor-arg>
</bean>

（3）P名称空间注入

xmlns:p="http://www.springframework.org/schema/p"
<bean id="person" class="Property.Person" p:pname="lucy"></bean>

七、Spring整合web项目原理

1 加载spring核心配置文件，

（1）new对象，功能可以实现，效率很低

2 实现思想：把加载配置文件和创建对象过程，在服务器启动时候完成

3 实现原理

（1）ServletContext对象

（2）监听器

（3）具体使用：

在服务器启动时候，为每个项目创建一个ServletContext对象
在ServletContext对象创建时候，使用监听器可以具体到ServletContext对象在什么时候创建
使用监听器监听到ServletContext对象创建时候，
加载spring配置文件，把配置文件配置对象创建
把创建出来的对象放到ServletContext域对象里面（setAttribute方法）
获取对象时候，到ServletContext域得到（getAttribute方法）

八、Spring的bean管理（注解方式）

注解介绍：

1 代码里面特殊标记，使用注解可以完成功能

2 注解写法 @注解名称(属性名称=属性值)

3 注解使用在类上面，方法上面和属性上面

开启注解扫描

（1）<!--到包里面扫描类、方法、属性上是否有注解--
        anno是需要扫描的包>
<context:component-scan base-package="anno"></context:component-scan>

注解创建对象

在创建对象的类上面使用注解实现

@Component(Value=“user”)

（1）@Component

（2）@Controller

（3）@Service

（4）@Repository

目前这四个注解功能是一样的，都创建对象

注解注入属性

1 创建service类，创建dao类，在service得到dao对象
注入属性第一个注解 @Autowired：自动扫描
注入属性第二个注解 @Resource(name=“user”) 标出注入对象的id

九、AOP

AOP原理

传统的纵向抽取机制来解决功能扩展，需要继承或者修改源代码

ddd

AOP采用横向抽取机制，使用动态代理的方式扩展功能
在这里插入图片描述

Joinpoint（连接点）: 类里面可以被增强的方法，这些方法称为连接点

Pointcut（切入点）:所谓切入点是指我们要对哪些Joinpoint进行拦截的定义.

Advice（通知/增强）:所谓通知是指拦截到Joinpoint之后所要做的事情就是通知.通知分为前置通知,后置通知,异常通知,最终通知,环绕通知(切面要完成的功能)

包括前置、后置、异常、最终、环绕通知

Aspect（切面）: 是切入点和通知（引介）的结合

Introduction（引介）:引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field.

Target（目标对象）:代理的目标对象(要增强的类)

Weaving（织入）:是把增强应用到目标的过程.把advice 应用到 target的过程

Proxy（代理）:一个类被AOP织入增强后，就产生一个结果代理类

Spring的aop操作

在spring里面进行aop操作，

使用aspectj实现，xml方式

aspectj不是spring一部分，和spring一起使用进行aop操作
Spring2.0以后新增了对AspectJ支持

使用aspectj实现aop有两种方式

基于aspectj的xml配置
基于aspectj的注解方法

常用的表达式

execution(<访问修饰符>?<返回类型><方法名>(<参数>)<异常>)

（1）execution(* cn.itcast.aop.Book.add(…)）任意返回类型、add()方法

（2）execution(* cn.itcast.aop.Book.*(…)) 任意返回类型、Book包类中的方法

（3）execution(* * . *(…)) 任意类中的任意方法

（4）匹配所有save开头的方法 execution(* save*(…))

Aspectj的aop操作

<!-- 1 配置对象-->
    <bean id="book" class="aop.Book"></bean>
    <bean id="strongbook" class="aop.StrongBook"></bean>
<!-- 2 配置aop操作-->
    <aop:config>
        <!-- 2.1配置切入点-->
        <aop:pointcut id="pointcut1" expression="execution(* aop.Book.*(..))"/>
        <!-- 2.2配置切面 把增强用到方法-->
        <aop:aspect ref="strongbook" >
            <!--配置增强类型 在ref中使用method增强-->
            <aop:before method="before1" pointcut-ref="pointcut1"></aop:before>
            <aop:after method="after1" pointcut-ref="pointcut1"></aop:after>
            <aop:around method="around1" pointcut-ref="pointcut1"></aop:around>
        </aop:aspect>
    </aop:config>

环绕通知，可以传入 proceedingJoinPoint参数，来在增强方法中调用切点方法

public void around1(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
    //之前
    System.out.println("befor");
    //执行增强的方法
    proceedingJoinPoint.proceed();
    System.out.println("after");
}