【Spring】（一）spring快速入门

最新推荐文章于 2024-04-27 19:20:17 发布

阿毛被狼叼走啦

最新推荐文章于 2024-04-27 19:20:17 发布

阅读量100

点赞数

分类专栏： myspring 文章标签： myspring

本文链接：https://blog.csdn.net/siting97/article/details/95309004

版权

myspring 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

文章目录

一、认识spring框架
二、Spring IoC和DI简介
- 2.1 IoC：Inverse of Control（控制反转）
- 2.2 DI：Dependency Injection（依赖注入）
三、Spring AOP简介

本文参考：
https://www.cnblogs.com/wmyskxz/p/8820371.html

一、认识spring框架

spring 框架是Java应用最广的框架。它的成功来源于理念，而非技术本身。它的理念主要包括Ioc(Inversion of Control) 控制反转和AOP(Aspect Oriented Programming) 面向切面编程。

1.1 什么是spring

1、spring 是一个轻量级 DI/IoC 和AOP容器开源框架，来源于Rod Johnson 在其著作《Expert one on one J2EE design and development》中阐述的部分历练和原型衍生而来。
2、Spring提倡以"最少侵入"的方式来管理应用中的代码，这意味着我们可以随时安装或者写在Spring

适用范围：任何Java应用
Spring的根本使命：简化Java开发

尽管 J2EE 能够赶上 Spring 的步伐，但 Spring 并没有停止前进， Spring 继续在其他领域发展，而 J2EE 则刚刚开始涉及这些领域，或者还没有完全开始在这些领域的创新。移动开发、社交 API 集成、NoSQL 数据库、云计算以及大数据都是 Spring 正在涉足和创新的领域。Spring 的前景依然会很美好。

1.2 Spring中的常用术语

框架:是能完成一定功能的半成品。
- 框架能够帮助我们完成的是：项目的整体框架、一些基础功能、规定了类和对象如何创建，如何协作等。当我们开发一个项目时，使用框架帮助我们完成了一部分功能，我们自己在完成一部分，那这个项目就完成了。
非侵入式设计:。
- 从框架的角度可以理解为，无需继承框架提供的任何类
- 这样我们在更换框架时，之前写过的代码几乎可以继续使用
轻量级和重量级:
- 轻量级是相对于重量级而言的，轻量级一般就是非入侵性的、所依赖的东西非常少、资源占用非常少、部署简单等等。其实就是比较容易使用，而重量级正好相反。
JavaBean:
- 即符合JavaBean规范的Java类
POJO: 即plain Old Java Objects，简单老式Java对象
- 他可以包含业务逻辑或者持久化逻辑，但不担当任何特殊角色且不继承或不实现任何其他Java框架的类或者接口。
- bean 的各种名称——虽然 Spring 用 bean 或者 JavaBean 来表示应用组件，但并不意味着 Spring 组件必须遵循 JavaBean 规范，一个 Spring 组件可以是任意形式的 POJO。
容器:
- 在日常生活中容器是一种盛放东起的器具，从程序设计角度看就是装对象的对象，因为存在放入，拿出等操作，所以容器还要管理对象的生命周期。

1.3 spring的优势

低侵入 / 低耦合（降低组件之间的耦合度，实现软件各层之间的解耦）
声明式事务管理（基于切面和惯例）
方便集成其他框架（如MyBatis、Hibernate）
降低 Java 开发难度
Spring 框架中包括了 J2EE 三层的每一层的解决方案（一站式）

1.4 spring能帮我们做什么

Spring能帮我们根据配置文件创建以及组装对象之间的依赖关系
Spring面向切面编程能帮我们无耦合实现日志记录，性能统计，安全控制
Spring能够非常简单的帮我们管理数据库事务
Spring还提供了与第三方数据访问框架（如Hibernate、JPA）无缝集成，而且自己也提供了一套JDBC访问模板来方便数据库访问。
Spring 还提供与第三方Web（如Struts1/2、JSF）框架无缝集成，而且自己也提供了一套Spring MVC框架，来方便web层搭建。
Spring 能方便的与Java EE（如Java Mail、任务调度）整合，与更多技术整合（比如缓存框架）

1.5 Spring的框架结构

在这里插入图片描述
-Data Access/Integration层包含有JDBC、ORM、OXM、JMS和Transaction模块。

Web层包含了Web、Web-Servlet、WebSocket、Web-Porlet模块。
AOP模块提供了一个符合AOP联盟标准的面向切面编程的实现。
Core Container(核心容器)：包含有Beans、Core、Context和SpEL模块。
Test模块支持使用JUnit和TestNG对Spring组件进行测试。

二、Spring IoC和DI简介

2.1 IoC：Inverse of Control（控制反转）

读作“反转控制”，更好理解，不是什么技术，而是一种设计思想，就是将原本在程序中手动创建对象的控制权，交由Spring框架来管理。
正控：若要使用某个对象，需要自己去负责对象的创建
反控：若要使用某个对象，只需要从 Spring 容器中获取需要使用的对象，不关心对象的创建过程，也就是把创建对象的控制权反转给了Spring框架
好莱坞法则：Don’t call me ,I’ll call you

一个例子
控制反转显然是一个抽象的概念，我们举一个鲜明的例子来说明。

在现实生活中，人们要用到一样东西的时候，第一反应就是去找到这件东西，比如想喝新鲜橙汁，在没有饮品店的日子里，最直观的做法就是：买果汁机、买橙子，然后准备开水。值得注意的是：这些都是你自己“主动”创造的过程，也就是说一杯橙汁需要你自己创造。
在这里插入图片描述
然而到了今时今日，由于饮品店的盛行，当我们想喝橙汁时，第一想法就转换成了找到饮品店的联系方式，通过电话等渠道描述你的需要、地址、联系方式等，下订单等待，过一会儿就会有人送来橙汁了。

在这里插入图片描述
请注意你并没有“主动”去创造橙汁，橙汁是由饮品店创造的，而不是你，然而也完全达到了你的要求，甚至比你创造的要好上那么一些。

编写第一个Spring程序
环境搭建
开发spring至少需要使用的jar(5个+1个):
spring-aop.jar 开发AOP特性时需要的JAR
spring-beans.jar 处理Bean的jar
spring-context.jar 处理spring上下文的jar
spring-core.jar spring核心jar
spring-expression.jar spring表达式

1、在 Packge【pojo】下新建一个【Source】类

package pojo;
public class Source {  
    private String fruit;   // 类型
    private String sugar;   // 糖分描述
    private String size;    // 大小杯    
    /* setter and getter */
}

2、在【src】目录下新建一个【applicationContext.xml】文件，通过 xml 文件配置的方式装配我们的 bean

<?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 name="source" class="pojo.Source">
        <property name="fruit" value="橙子"/>
        <property name="sugar" value="多糖"/>
        <property name="size" value="超大杯"/>
    </bean>
</beans>

2、在 Packge【test】下新建一个【TestSpring】类：

public class TestSpring {
    public static void main(String[] args){
        ApplicationContext context = new ClassPathXmlApplicationContext(
                new String[]{"applicationContext.xml"}
        );

        Source source = (Source) context.getBean("source");
        System.out.println(source.getFruit());
        System.out.println(source.getSugar());
        System.out.println(source.getSize());
    }
}

运行测试代码。可以正常拿到xml配置的bean
在这里插入图片描述
总结
传统的方式：通过new关键字主动创建一个对象
传统的方式：通过new关键字主动创建一个对象
IoC方式：对象的生命周期由Spring来管理，直接从Spring那里去获取一个对象。 IOC是反转控制 (Inversion Of Control)的缩写，就像控制权从本来在自己手里，交给了Spring。
在这里插入图片描述

2.2 DI：Dependency Injection（依赖注入）

指 Spring 创建对象的过程中，将对象依赖属性（简单值，集合，对象）通过配置设值给该对象
继续上面的例子
1、在 Packge【pojo】下新建一个【JuiceMaker】类：

package pojo;
public class JuiceMaker {
    // 唯一关联了一个 Source 对象
    private Source source = null;

    /* setter and getter */
    public String makeJuice(){
        public String makeJuice(){
        String juice = "xxx用户点了一杯" + source.getFruit() + source.getSugar() + source.getSize();
        System.out.println(source);
        return juice;
    	}
    }
    public JuiceMaker() {
    	System.out.println("JuiceMaker无参构造————该JuiceMaker地址为"+this);
    }
}

2、在 xml 文件中配置 JuiceMaker 对象：
注意：这里要使用 ref 来注入另一个对象

<?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 name="source" class="pojo.Source">
        <property name="fruit" value="橙子"/>
        <property name="sugar" value="多糖"/>
        <property name="size" value="超大杯"/>
    </bean>
    <bean name="juickMaker" class="pojo.JuiceMaker">
        <property name="source" ref="source" />
    </bean>
</beans>

3、测试代码

public class TestSpring {

    public static void main(String[] args){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-context.xml");

        Source source = context.getBean("source",Source.class);
        System.out.println(source.getFruit());
        System.out.println(source.getSugar());
        System.out.println(source.getSize());
        
        JuiceMaker juiceMaker = context.getBean("juiceMaker", JuiceMaker.class);
        String str = juiceMaker.makeJuice();
        System.out.println(str);
    }
}

运行测试代码
在这里插入图片描述
如上运行结果，可以得出以下结论。
1、默认配置文件一加载就会创建对象（可配置）
2、对象创建默认为单例模式。从上面结果可以看出，JuiceMaker里的source属性的地址和最初创建的source对象是同一个。

总结：IoC 和 DI 其实是同一个概念的不同角度描述，DI 相对 IoC 而言，明确描述了“被注入对象依赖 IoC 容器配置依赖对象”

三、Spring AOP简介

如果说IoC是Spring的核心，那么面向切面变成就是Spring最为重要的功能之一了，在数据库十五中面向切面编程被广泛使用。

3.1 什么是AOP

AOP即Aspect Oriented Program 面向切面编程

首先，在面向切面编程的思想里面，把功能分为核心业务功能和周边功能。

所谓核心功能，比如登陆，增加数据，删除数据都叫核心业务
所谓周边功能，比如性能统计，日志，事务管理等等
周边功能在Spring 面向切面编程AOP思想里面，即被定义为切面

在面向切面编程AOP的思想里面，核心业务功能和切面功能分别独立进行开发，然后把切面功能和核心业务功能 “编织” 在一起，这就叫AOP。

3.2 AOP目的及相关概念

AOP能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

切入点（Pointcut）
- 在哪些类、哪些方法上切入（where）
通知（Advice）
- 在方法执行的什么时间做什么
- when：方法前/方法后/方法前后
- what：增强的功能
切面（aspect）
- 切面 = 切入点 + 通知，通俗点就是：在什么时机，什么地方，做什么增强
织入（Weaving）
- 把切面加入到对象，并创建出代理对象的过程。（有Spring来完成）

3.3 AOP编程

1、创建ProductService类并在xml文件中装配该bean:

package service;

public class ProductService {
    public void doSomeService(){
        System.out.println("doSomeService");
    }
}

<bean name="productService" class="service.ProductService" />

2、准备日志切面

package aspect;

import org.aspectj.lang.ProceedingJoinPoint;

public class LoggerAspect {  
    public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("start log:" + joinPoint.getSignature().getName());
        Object object = joinPoint.proceed();
        System.out.println("end log:" + joinPoint.getSignature().getName());
        return object;
    }
}

3、在xml文件中声明业务对象和日志切面

<?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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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/aop
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
   http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <bean name="productService" class="service.ProductService" />
    <bean id="loggerAspect" class="aspect.LoggerAspect"/>

    <!-- 配置AOP -->
    <aop:config>
        <!-- where：在哪些地方（包.类.方法）做增加 -->
        <aop:pointcut id="loggerCutpoint"
                      expression="execution(* service.ProductService.*(..)) "/>

        <!-- what:做什么增强 -->
        <aop:aspect id="logAspect" ref="loggerAspect">
            <!-- when:在什么时机（方法前/后/前后） -->
            <aop:around pointcut-ref="loggerCutpoint" method="log"/>
        </aop:aspect>
    </aop:config>
</beans>

4、测试类

public class TestSpring {

    public static void main(String[] args){
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-context.xml");
        ProductService s = context.getBean("productService", ProductService.class);
        s.doSomService();
    }
}

运行测试代码，可以看出在业务方法运行前后输出了日志信息
在这里插入图片描述

阿毛被狼叼走啦

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
【Spring】（一）spring快速入门

文章目录一、Spring简介1.1 Spring的特点一、Spring简介Spring是一个开放源代码的设计层面框架，他解决的是业务逻辑层和其他各层的松耦合问题。因此他将面向接口的编程思想贯穿整个系统应用。Spring是于2003年兴起的一个轻量级的java开发框架。简单来说，Spring是一个分层的JavaSE/EE full-stack（一站式）轻量级开源框架1.1 Spring的特点...
复制链接

扫一扫

专栏目录