SSM--Spring框架入门学习

最新推荐文章于 2023-04-06 19:07:52 发布

望山。

最新推荐文章于 2023-04-06 19:07:52 发布

阅读量167

点赞数

分类专栏： SSM 文章标签： spring

本文链接：https://blog.csdn.net/weixin_53244569/article/details/119671878

版权

SSM 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一.Spring框架

1.概述

在这里插入图片描述
Spring是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。Spring框架的不光是技术牛，而是它的核心思想更牛，它不重复发明轮子，而是"拿来主义"，把业界做的最好的技术黏合起来形成一个强大的企业级的应用框架。

Spring 框架是一个分层架构，由7个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式，如下图所示：
在这里插入图片描述
组成 Spring 框架的每个模块（或组件）都可以单独存在，或者与其他一个或多个模块联合实现。每个模块的功能如下：

三大核心组件的关系
Bean、Context、Core三大核心组件的关系：

Bean 包装的是 Object，而 Object 必然有数据，如何给这些数据提供生存环境就是 Context要解决的问题，对 Context 来说它就是要发现每个 Bean 之间的关系，为它们建立这种关系并且要维护好这种关系。所以 Context 就是一个Bean关系的集合，这个关系集合又叫 Ioc 容器，一旦建立起这个 Ioc 容器后 Spring 就可以为你工作了。那 Core 组件又有什么用武之地呢？其实Core 就是发现、建立和维护每个 Bean 之间的关系所需要的一些类的工具，从这个角度看来，Core 这个组件叫 Util 更能让你理解。

把Bean 比作一场演出中的演员的话，那 Context 就是这场演出的舞台背景，而 Core应该就是演出的道具了。只有他们在一起才能具备能演出一场好戏的最基本的条件。当然有最基本的条件还不能使这场演出脱颖而出，还要他表演的节目足够的精彩，这些节目就是 Spring 能提供的特色功能了。

主要jar组成
在这里插入图片描述

核心概念

在这里插入图片描述

Spring框架功能非常丰富，核心的功能是：IOC DI AOP
IOC:控制反转，指把创建对象的过程交给了 Spring
DI:把依赖注入，指把对象间的依赖关系自动维护
AOP:是补充了OOP的不足
Spring框架两大核心：IoC和DI

IoC（Inversion of Control）简单来说就是将对象Object的创建的权力及对象的生命周期的管理过程交由Spring框架来处理，从此在开发过程中不在需要关注对象的创建和生命周期的管理，而是在需要的时候由Spring框架提供，这个由Spring框架管理对象创建和生命周期的机制称之为控制反转。
在创建对象的过程中Spring可以依据对象的关系，自动把其它对象注入（无需创建对象，直接拿着使用）进来，这个过程称之为DI（Dependency Injection）依赖注入。
总结下Spring核心就干了两件事：

创建对象
设置对象的关联关系
IoC底层代码：{“cn.tedu.User”,new User()}
IOC（Inversion of Control），控制反转。

就是指将对象的创建，对象的存储(map)，对象的管理(依赖查找,依赖注入)交给了spring容器。
在这里插入图片描述

2.IOC的XML实现方式

是指把创建对象管理对象的过程交给了Spring框架

创建Maven Module

File-New-Module-Maven-next-输入ModuleName-ok
导入jar包(不需要了,被Spring Boot整合了)

创建Hello类

在这里插入图片描述

创建配置文件

<?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的信息
        id用来作为这个bean的唯一标识,class用来描述类的全路径
    -->
    <bean id="hello" class="cn.tedu.spring.Hello"></bean>
</beans>

测试

package cn.tedu.test;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    @Test
    public void get(){
        //1,读取配置文件
        ClassPathXmlApplicationContext spring =
                        new ClassPathXmlApplicationContext(
                            "spring-config.xml");
        //2,直接getBean
        Object o = spring.getBean("hello");
        System.out.println(o);//cn.tedu.spring.Hello@45752059
    }
}

小结

这就是spring框架的IoC，控制反转。之前我们自己new出新类。new User();变成由一个初始化的xml配置文件来创建，也就是由spring容器来创建。遍历xml配置文件，读取到<bean>，获取到class属性的类的全路径，利用反射创建这个类。

在java范畴中万物皆Object,在Spring中万物皆Bean。Bean是Spring的核心、基础、根源。

3.IOC的注解实现方式

在这里插入图片描述
####创建User类

package cn.tedu.ioc;

import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Service;

@Component("a")//自动完成IOC,自己指定bean的名字a->{”a“，new User()}spring提供的，用来ioc
//@Component//默认的bean的名字，user
//@Component 自动完成IOC->{”user“，new User()}
//@Controller//spring提供的，用来ioc
//@Service//spring提供的，用来ioc
public class User {
    public void get(){
        System.out.println(123);
    }
}

修改配置文件

<?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 https://www.springframework.org/schema/context/spring-context.xsd">

    <!--配置Bean的信息
        作为spring容器里的一个bean存在，本质上就是map{hello，new Hello}
        id：用来作为这个bean的唯一标识
        class：用来描述类的全路径
        IOC->{"hello",new Hello}
    -->
    <bean id="hello" class="cn.tedu.spring.Hello"></bean>
    
    
    <!--配置包扫描
    base-package指定一个包的路径,扫描范围可以自己定
    -->
    <context:component-scan base-package="cn.tedu"></context:component-scan>

</beans>

测试

package cn.tedu.test;

import cn.tedu.people.Person;
import cn.tedu.ioc.User;
import cn.tedu.spring.Hello;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    @Test
    public void get(){
        //1.读取配置文件
        ClassPathXmlApplicationContext spring =
                new ClassPathXmlApplicationContext("spring-config.xml");
        //2.直接getBean
        //根据id获取bean,beanname就是类名,首字母变小写
        Object o = spring.getBean("hello");
        System.out.println(o);//cn.tedu.spring.Hello@1a677343

        //调用子类的方法--向下转型/造型
        Hello h = (Hello) o;
        h.get();

        //获取注解的bean
        User u = (User)spring.getBean("a");
        System.out.println(u);//cn.tedu.ioc.User@5acf93bb
        u.get();

        Person p = (Person)spring.getBean("person");
        System.out.println(p);
        p.get();
    }
}

总结

在这里插入图片描述

4.DI 依赖注入

1.概述

是指对象间的依赖关系,可以由框架来完成

2.简单模拟

在这里插入图片描述

创建Dept类

package cn.tedu.di;

public class Dept {
    String name="java软件开发一部";
    @Override
    public String toString() {
        return "Dept{" +
                "name='" + name + '\'' +
                '}';
    }
}

创建Emp类

package cn.tedu.di;

public class Emp {
    String name = "jack";
    //绑定两个类间的关系
    private Dept d;
    public Dept getD() {
        return d;
    }
    public void setD(Dept d) {
        this.d = d;
    }
    @Override
    public String toString() {
        return "Emp{" +
                "name='" + name + '\'' +
                ","+"d='"+d+'\''+
                '}';
    }
}

测试

package cn.tedu.di;

import org.junit.Test;

public class Test01 {
    @Test
    public void di(){
        Dept d = new Dept();
        System.out.println(d);//Dept{name='java软件开发一部'}
        Emp e = new Emp();
        System.out.println(e);//Emp{name='jack',d='null'}
        //di--把两个对象间的关系依赖注入
        e.setD(d);
        System.out.println(e);
        //已经实现了di的效果,在查询e把关联的d的信息也查到了
        //Emp{name='jack', d=Dept{name='java软件开发一部'}}
    }

}

5.使用Spring实现DI

在这里插入图片描述

创建Teacher类

package cn.tedu.di2;

import org.springframework.stereotype.Component;
@Component
public class Teacher {
    String name = "tony";
    @Override
    public String toString() {
        return "Teacher{" +
                "name='" + name + '\'' +
                '}';
    }
}

创建Student类

package cn.tedu.di2;

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

@Component
public class Student {
    @Autowired//底层是反射，当于框架完成了:new Student().setTeacher(new Teacher());
    Teacher t ;
    String name = "蔡徐坤";

    @Override
    public String toString() {
        return "Student{" +
                "t=" + t +
                ", name='" + name + '\'' +
                '}';
    }
}

创建配置文件,包扫描

<?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 https://www.springframework.org/schema/context/spring-context.xsd">
<!--    包扫描：扫描指定指定包路径下的所有类，谁有ioc的注解就扫描谁-->
    <context:component-scan base-package="cn.tedu.di2"></context:component-scan>
</beans>

测试

package cn.tedu.di2;

import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test01 {

    @Test
    public void di2(){
        //1.读取xml文件
        ClassPathXmlApplicationContext spring =
                new ClassPathXmlApplicationContext("spring-config.xml");
        //2.getBean
        Object o = spring.getBean("student");
        //di:查学生信息的同时也查到了老师信息,两个对象之间的依赖注入
        //Student{t=Teacher{name='tony'}, name='蔡徐坤'}
        System.out.println(o);
    }
}

6.小结

面试：IoC和DI

在平时的java应用开发中，我们要实现某一个功能或者说是完成某个业务逻辑时可能需要多个对象来协作完成，在没有使用Spring的时候，每个对象在需要使用他的合作对象时，自己均要使用像new object() 这样的语法来将合作对象创建出来，这个合作对象是由自己主动创建出来的，创建合作对象的主动权在自己手上，自己需要哪个合作对象，就主动去创建，创建合作对象的主动权和创建时机是由自己把控的，而这样就会使得对象间的耦合度高了，A对象需要使用合作对象B来共同完成一件事，A要使用B，那么A就对B产生了依赖，也就是A和B之间存在一种耦合关系，并且是紧密耦合在一起，而使用了Spring之后就不一样了，创建合作对象B的工作是由Spring来做的，Spring创建好B对象，然后存储到一个容器里面，当A对象需要使用B对象时，Spring就从存放对象的那个容器里面取出A要使用的那个B对象，然后交给A对象使用，至于Spring是如何创建那个对象，以及什么时候创建好对象的，A对象不需要关心这些细节问题(你是什么时候生的，怎么生出来的我可不关心，能帮我干活就行)，A得到Spring给我们的对象之后，两个人一起协作完成要完成的工作即可。

所以控制反转IoC(Inversion of Control)是说创建对象的控制权进行转移，以前创建对象的主动权和创建时机是由自己把控的，而现在这种权力转移到第三方，比如转移交给了IoC容器，它就是一个专门用来创建对象的工厂，你要什么对象，它就给你什么对象，有了 IoC容器，依赖关系就变了，原先的依赖关系就没了，它们都依赖IoC容器了，通过IoC容器来建立它们之间的关系。

DI(依赖注入)其实就是IOC的另外一种说法，DI是由Martin Fowler 在2004年初的一篇论文中首次提出的。他总结：控制的什么被反转了？就是：获得依赖对象的方式反转了。

IoC是设计思想，IoC有三个核心：BeanFactory、反射、DI。BeanFactory利用反射实现对象的创建，DI实现对象关系管理。

自动装配

利用注解方式，我们只需要写@Autowired注解，底层就会去容器中找对应的对象，如果有获取到，反射调用其对应的set方法，设置。而这个调用过程都是自动，我们没有手工去写set方法。所以这个过程也称为自动装配。

7.AOP面向切面编程

1.概念

Spring核心特征中除了IoC控制反转、DI依赖注入，还有一个核心就是强大的面向切面编程AOP（Aspect Oriented Programming）的实现。

Sring AOP有三要素：

Aspect定义切面；
通过通知（Advice）来指定具体做什么事情。如方法执行前做什么，方法执行后做什么，抛出异常做什么，从而实现对象行为（方法）的增强；
具体通过切点（PointCut）配置切点表达式（expression）来指定在哪些类的哪些方法上织入（ware）横切逻辑；被切的地方叫连接点（JoinPoint）；
在这里插入图片描述
是一个面向切面编程的思想，补充了OOP的不足，实现的效果，对方法的增强，本质上就是在执行方法的前后添加功能。
经典的使用场景 / 统计性能分析 / 权限管理 / 事务管理/日志/缓存……

**好处：**让程序猿更专注业务代码本身

切面：本质上就是一个类
通知：本质上就是一个方法，分为前置通知和环绕通知，返回后通知，异常通知
前置通知before：是方法执行前要执行的功能
后置通知after：是方法执行后要执行的功能
环绕通知around：是方法执行前后都要执行的功能
返回后通知afterReturning
异常通知afterThrowing
在这里插入图片描述

**切点：**指定哪些类里的哪些方法要有通知的功能
**常用AOP注解：**
	@Aspect：表示一个切面类
	@Before：表示是一个前置通知
	@After : 表示是一个后置通知
	@Around : 表示是一个环绕通知
	@PointCut : 表示切点

多切面执行顺序
下面是两个切面各通知的执行顺序：

在这里插入图片描述

2.步骤

1.添加ja包

<!--添加aop依赖包-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>

2.使用

package cn.tedu.service;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Service;

@Service//ioc
@Aspect//标记这是一个aop的类：切面（由切点和通知组成）
public class AopAspect {
    //切面由切点和通知组成
    //切点表达式：（指定具体要用通知的类或者方法）
    //*是通配符 ..表示0到n个
    //*表示1个 ..表示多个 *依次代表方法返回值，类名，方法名，(..)是参数列表
                        //方法返回值/包路径/子包/类名/方法名/参数列表
    @Pointcut("execution( * cn.tedu.service..*.*(..))")
    public void point(){

    }
    //通知（是一个方法自定义功能）
    @Around("point()")
    public Object doAround(ProceedingJoinPoint joinPoint)
            throws Throwable{

        long time =  System.currentTimeMillis();//计时开始
        //去执行你的业务方法
        Object o = joinPoint.proceed();

        String methodname = joinPoint.getTarget().getClass().getName()//获取类名
                +"."+joinPoint.getSignature().getName();//获取方法名
        time = System.currentTimeMillis()-time;//计时结束

        System.out.println("根据aop统计,"+methodname+"方法执行时间是："+time);
        return o;
    }
}

3.测试

启动服务器,访问指定包里的资源时,就会自动触发切面中通知的功能.
在这里插入图片描述

望山。

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
SSM--Spring框架入门学习

一.Spring1.概述功能非常丰富，核心的功能是：IOC DI AOPIOC:控制反转，指把创建对象的过程交给了SpringDI:把依赖注入，指把对象间的依赖关系自动维护AOP:是补充了OOP的不足Spring框架两大核心：IoC和DIIoC（Inversion of Control）简单来说就是将对象Object的创建的权力及对象的生命周期的管理过程交由Spring框架来处理，从此在开发过程中不在需要关注对象的创建和生命周期的管理，而是在需要的时候由Spring框架提供，这个由Sp
复制链接

扫一扫