spring教程 csdn（spring教程菜鸟）



目录

全网最详细的Spring入门教程

一.Spring的来源

1.耦合代码如下：

2.解耦合代码如下：

二.Spring的本质

基本概念：

三.Spring的使用

1.无Spring注解具体实现步骤：

1.1.大致步骤：

创建 接口1 类1 接口2 类2

写 bean文件

写bean的配置

获取类

1.2.有简单类型依赖和无依赖的类实现方式如下：

项目框架：

pom.xml

ApplicationContext.xml

测试类(需要被容器创建的类)

客户类(使用者)：

运行结果：

1.3.有集合类型依赖的类实现方式如下：

项目框架：

pom.xml

ApplicationContext.xml

测试类(需要被容器创建的类)

客户类(使用者)：

运行结果：

1.4.有引用类型依赖的类实现方式如下：

项目框架：

pom.xml

ApplicationContext.xml

测试类(需要被容器创建的类)

客户类(使用者)：

运行结果：

2.Spring注解具体实现步骤：

plus：Spring中的常用注解

2.1.大致步骤：

创建 接口1 类1 接口2 类2

在需要new的类加上注解

写 bean文件

写bean的配置 ： 扫描命令代码

获取类

2.2.1有简单类型依赖和无依赖的类实现方式如下：

项目框架：

pom.xml

ApplicationContext.xml

测试类(需要被容器创建的类)

客户类(使用者)

运行结果：

2.2.2有简单类型依赖和无依赖的类实现方式如下：优化版：

项目框架：

pom.xml

SpringBeanConfiguration类的配置：

测试类(需要被容器创建的类)

客户类(使用者)

运行结果：

2.3.有集合类型依赖的类实现方式如下：

项目框架：

pom.xml

SpringBeanConfiguration类的配置：

测试类(需要被容器创建的类)

客户类(使用者)

运行结果：

2.4.有引用类型依赖的类实现方式如下：

项目框架：

pom.xml

SpringBeanConfiguration类的配置：

被依赖的类

测试类(需要被容器创建的类)：

客户类(使用类)

运行结果：

四.Spring的优化

1.Spring注入propertis配置文件：

1.1无注解开发注入properties配置文件：

1.2有注解开发注入properties配置文件：

2.Spring注入第三方类

2.1无注解注入第三方类

2.2有注解注入第三方类

第一种方法：

第二种方法：

2.3在第三方类里面加入依赖类型

3.整合MyBatis：

3.1mybatis的复习

3.2整合操作分析：

3.3.Spring注解方式整合MyBatis具体操作

1.环境准备：

JDK:

Maven：

建立数据库表：

2.项目框架：

3.pom：

4.数据源的配置文件：MyBatis.properties:

5.pojo类：

6.Mapper类

7.实现接口：

8.实现类：

9.Jdbc配置类：

10.Mybatis配置类：

11.核心最重要：Spring配置类 ！！！

12.测试类

13.测试结果：

4.AOP面向切面编程：

面向切面编程来源和概念：

项目框架：

pom.xml

实现的接口 和实现的类如下：

MyAdvice类的书写：

SpringBeanConfiguration的书写

客户类(使用类)

运行结果：

5.Spring整合SpringMVC

SpringConfig类：

SpringMVC类：

ServletContainerIniti类：

SpringMVCConfig类：

---

其实spring的来源就是一个词语，完全解耦，为什么叫做完全解耦，还得从两个类的调用说起，接口1的实现类，我们叫做类1，接口2的实现类，我们叫做类2，现在我们有一个前提条件，就是，类2里面去new类1，且把类1的方法给到类2使用，我们现在形容类2和类1有依赖关系，也就是类2要依赖类1，那么如果出现一个境况也就是如果类1发生了改变，那么我们如何去使用类2，那我们在使用类2的时候就需要去改变类2里面的代码，一方面需要从新new一次类1，二方面需要把类2里面的方法对应新的类1的方法。此时这样的依赖之间的耦合性就会非常高。所以我们就有了一个策略，类2里面写new接口1，也就是在类二里面写一个set方法，这个方法的传参是一个实现类，方法的内容是把传入的实现类给到类2里面new的接口1，也就是说类2可以通过set的方法给类2里面new的接口1变成实现类1，这样就在我们每一次new 类2的时候，只需要new类2后，调用一次set方法就可以实现类2里面new类1，这样我们就实现了不用每次更改接口1的实现类的时候需要在类2里面修改代码了，我们就实现了一个解耦。

什么是耦合性：

类1实现接口1 类2实现接口2 而类2里面创建了类1，且把类1的方法调用在类2的方法中

1.耦合代码如下：

客户使用类：

如上明显是有耦合性的两个类，一旦类1的代码需要改变，类2也得需要重新new，且重新把类1的方法放入类2的方法，

这样耦合性太高代码的使用就会很麻烦，所以就出现了如下的解决方法：

2.解耦合代码如下：

客户使用类：

这样就发现我们的类3里面的类1的创建不是我们主动去改类3的代码，而是我们客户自己进行一个set，等于说，我们类的创建的方式不是我们手动创建了，而是我们去接受类，这样就从一个主观变成了被动，这样大大的减少了代码的耦合。

本质其实就是完全解耦，用户通过容器来接受他们想要的类。就像我们把一些类放入到一个自动售卖机，我们

需要什么类就从里面拿，而不是自己去new。

基本概念：

这样我们类1的创建就有了这种方式创建，那么我们是不是也可以把类2的创建也可以这样创建呢，也是可以的，所以我们从上面来看，我们可以把类放在一个类似于set的这种结构和有客户new的结构里面，我们称这两种结构的总和叫做容器，也就是说我们可以通过容器来得到普通类，和有依赖关系的类，那么这些由容器创建的类叫做Bean，而这个解耦的技术叫做IOC，依赖反转技术，而用容器创建有依赖关系的类又叫做DI，也就是依赖注入，那么一下就出现了这几个名词，DI,IOC,bean，容器。

容器：创建类的一个封装的抽象概念。

bean：又容器创建的类的统称。

DI:由容器创建有依赖关系的类的技术，叫做依赖反转。

IOC：完全解耦，也就是包括有依赖关系的类的new和无依赖关系的new的统称的解耦的技术。

IOC技术是用容器放bean和DI。

而一个类可以依赖 简单数据类型 ，集合数据类型 ， 引用数据类型 ，其实说白了都是类

如何使用呢，刚才我们看到我们在使用多个类之间的关系的时候，我们在用Spring一共有几个必要的东西。

第一：得到无依赖的类。

接口1 类1 bean文件 bean的配置 获取类

第二：得到有依赖的类。

1.无Spring注解具体实现步骤：

1.1.大致步骤：

创建 接口1 类1 接口2 类2

写 bean文件

写bean的配置

获取类

1.2.有简单类型依赖和无依赖的类实现方式如下：

项目框架：

pom.xml

ApplicationContext.xml

测试类(需要被容器创建的类)

客户类(使用者)：

运行结果：

1.3.有集合类型依赖的类实现方式如下：

项目框架：

pom.xml

ApplicationContext.xml

测试类(需要被容器创建的类)

客户类(使用者)：

运行结果：

1.4.有引用类型依赖的类实现方式如下：

项目框架：

pom.xml

ApplicationContext.xml

测试类(需要被容器创建的类)

客户类(使用者)：

运行结果：

2.Spring注解具体实现步骤：

plus：Spring中的常用注解

@Component：使用在类上用于实例化Bean @Controller：使用在web层类上用于实例化Bean（作用于@Component一致） @Service：使用在service层类上用于实例化Bean（作用于@Component一致） @Repository：使用在dao层类上用于实例化Bean（作用于@Component一致） @Autowired：使用在字段上用于根据类型依赖注入 @Qualifier：结合@Autowired一起使用用于根据名称进行依赖注入 @Resource：相当于@Autowired+@Qualifier，按照名称进行注入 @Value：注入普通属性 @Scope：标注Bean的作用范围 @PostConstruct：使用在方法上标注该方法是Bean的初始化方法 @PreDestroy：使用在方法上标注该方法是Bean的销毁方法 以上的这些注解主要是替代 Bean 标签的配置。但是这些注解还不能全部替代xml配置文件，包括以下几个新注解：

@Configuration：用于指定当前类是一个Spring 配置类，当创建容器时会从该类上加载注解 @ComponentScan：用于指定Spring 在初始化容器时要扫描的包 @Bean：使用在方法上，标注将该方法的返回值存储到Spring 容器中 @PropertySource：用于加载.properties 文件中的配置 @Import：用于导入其他配置类

2.1.大致步骤：

创建 接口1 类1 接口2 类2

在需要new的类加上注解

写 bean文件

写bean的配置 ： 扫描命令代码

获取类

2.2.1有简单类型依赖和无依赖的类实现方式如下：

项目框架：

pom.xml

ApplicationContext.xml

测试类(需要被容器创建的类)

客户类(使用者)

运行结果：

2.2.2有简单类型依赖和无依赖的类实现方式如下：优化版：

项目框架：

pom.xml

同上面没有优化的pom的配置一样

SpringBeanConfiguration类的配置：

测试类(需要被容器创建的类)

客户类(使用者)

运行结果：

2.3.有集合类型依赖的类实现方式如下：

项目框架：

pom.xml

同上

SpringBeanConfiguration类的配置：

测试类(需要被容器创建的类)

客户类(使用者)

运行结果：

2.4.有引用类型依赖的类实现方式如下：

项目框架：

pom.xml

同上

SpringBeanConfiguration类的配置：

被依赖的类

测试类(需要被容器创建的类)：

客户类(使用类)

运行结果：

优化就是用spring这个ioc的思想和实现来new一下和整合一下我们经常用的东西。

比如我们用spring容器来整合mybatis，创建propertis类，整合springmvc。

1.Spring注入propertis配置文件：

如何用注解开发或者说用spring注入开发的方式来做到注解开发呢？

1.1无注解开发注入properties配置文件：

在bean文件中加入：

1.2有注解开发注入properties配置文件：

@PropertySource("classpath:data.properties") 

2.Spring注入第三方类

注入第三方类的意思是，我们需要注入到容器里面的类不是在我们new的实现类和实现接口里面，而是我们

自己需要从外部加载进来的类。

我们这里如下的举例就用我们在整合Mybatis时需要把datasource数据源放入到容器中

2.1无注解注入第三方类

2.2有注解注入第三方类

第一种方法：

把第三方类写一个类出来如下：

这里的重点的是 不是说bean这个类就不像之前不是第三方类那样是直接在类上面表controller，service，component，reposity这样，而是在一个可以返回类的方法上去做这个操作。

在bean类里面需要写如下import的配置：

第二种方法：

把第三方类写一个类出来如下：

注意这里是加了configuration

在bean的配置里面一定要配上扫描

总结就是要么就是在第三方类配置上configuration，然后bean类配上扫描，要么第三方类不配置，就在bean类里面import即可

2.3在第三方类里面加入依赖类型

通过传参的方式放入第三方bean类如下：

3.整合MyBatis：

3.1mybatis的复习

jdbc就5步：

获取mysql驱动

得到connection对象

得到statement执行语句对象

得到结果集对象resultset

得到结果

从而衍生到mybatis的四步

前提条件是写好配置文件和一个mapper也就是sql语句的文件：

sqlsessionfactory.builder()里面加入配置文件得到sqlsessionfactory

调用opensession的方法后得到sqlsession 也就是是类似于得到一个preparestatement类

用sqlsession对象去调用delete update select 方法，而如果是查询和更新的话 直接把放入数据库的类和

需要查询依据的数据字段和需要放入的内容放入这些方法中，被sqlsesion调用后，会操作进入数据库从而直接得到结果

如上是其中一种方法，还有一种方法是:

sqlsessionfactory.builder()里面加入配置文件得到sqlsessionfactory

调用opensession的方法后得到sqlsession 也就类似于得到一个preparestatement类

sqlsession调用getmapper后得到dao对象

对象执行对应的语句得到结果或者把数据传入数据库中

这两种方法的对比其实就是一个是把操作类集成了一个具体的类 这个具体的类里面的方法

的名字也就是配置文件对应的sql语句的id，而方法的传参就是语句执行传入数据库的值或者是

查询的依据对象，而方法返回的值是语句执行的结果。

具体实现方法可以参考下面老师写的博客：

Mybatis实现增删改查mybatis增删改查code袁的博客-CSDN博客

而这其中mybatis的得到dao对象其实就是

mybatis里面的mapper.xml的namespace 对应 dao的类名 ， mapper.xml里面的 id 对应dao的方法名

把一个dao类里面的多个方法对应 增删改查的方法mapper.xml里面的sql语句：

方法的传参就是放到数据库里面的东西，方法的返回值就是从数据库里面拿出来的东西

而方法名和mapper.xml里面的id名对应即可

3.2整合操作分析：

所以在整合mybatis的时候要主要是去整合如下代码：

把所有的步骤分为了两大块，第一块就是上面两行代码，第二块就是下面的两行代码：

那么先从第一块代码开始：

首先是数据源，也就是放入build的配置文件，配置文件里面有jdbc需要的配置和

1) 声明数据源DataSource，使用阿里的Druid连接池 2) 声明SqlSessionFactoryBean类，在这个类的内部创建SqlSessionFactory对象

3) 声明MapperScannerConfigurer类，在这个类的内部创建dao代理对象，创建的对象放在spring容器中 4) 声明service对象，把3)中的dao赋值给service对象属性

这里注意个细节，在原生mybatis开发中，创建sqlSessionFactory对象是需要mybatis-config.xml的，我们回顾，该配置文件中主要书写了三部分信息：

mybatis-config.xml 1.dataSource 记载数据库的连接信息 2.typeAliases 配置实体别名 3.mapper映射文件的注册

同理，使用SqlSessionFactoryBean来创建sqlSessionFactory对象，也需要这部分信息，需要这些，即依赖这些，就可以通过注入属性的方式得到这些信息。我们采用set注入的方式。

上面的三部分信息对应着SqlSessionFactoryBean的三个属性 1.dataSource–》指向数据库连接的配置 2.typeAliasesPackage–》指向实体类的包，可为该包下的所有类创建类名首字母小写的别名 3.mapperLocations–》值为通配符表达式，对所有匹配上的Mapper文件进行注册

此时mybatis-config.xml中的所有信息都通过注入的方式写到spring的配置文件中去了，所以mybatis-config.xml就可以不用了。

MapperScannerConfigurer spring提供MapperScannerConfigurer类来封装第二部分代码，用于生成userDao对象。 在原生开发步骤中，我们需要是用sqlSessionFactory对象来获得sqlSession对象，再指定XXXDao的class，进而获得对应的dao对象。 在spring的封装下，我们只需要在配置文件中对MapperScannerConfigurer进行配置，

sqlSessionFactoryBeanName-》sqlSessionFactory对象需要被注入 basePackage-》指定DAO接口所在的包

从上面的mybatis复习和用无注解spring整合mybatis可以看出，其实就是用容器的方式，

把sqlsessionfactoryBuilder(mybatisconfig.xml) 和 sqlsessionfactory.opensession() 用 sqlsessionfactorybean来代替

而 sqlsession.getmapper 的操作 用mapperscannerconfigurer 类来代替

这两个类里面又分别由datasource 和 mapper需要创建，所以 最后就整合成了 创建这两个类，在用spring创建这两个

类的过程中就是其实就做了这些操作。所以推断的意思是在bean中依赖注入这些类的时候就是在做如上几步操作。

总结一下：

1.

bean注入sqlsessionfactorybean和mapperscannerconfigurer => 也就是在new前面两个类的过程中有操作如下步骤sqlsessionfactoryBuilder(mybatisconfig.xml) 和 sqlsessionfactory.opensession() sqlsession.getmapper =>

所以最后mapper也就是实现的mapper接口，可以通过spring获取，如果需要获取实现类，就在依赖注入一次实现类即可。

往下推

2.

就是在依赖注入这如上两个类的过程中，有一些依赖也需要写到bean中，如注入 sqlsessionfactorybean时就有

dataSource类，configLocation变量，和 typeAliasesPackage。所以需要注入一次datasource，又因为datasoure的value依赖于一个properties文件所以要配置 <context:property-placeholder location="classpath:jdbc-config.properties"/>。

而在注入mapperscannerconfigurer时候又需要一个 dao，所以也要写到bean里面去。

那么汇总就需要在bean中写

1. <context:property-placeholder location="classpath:jdbc-config.properties"/>
2. datasource 包括 datasoure的value
3. sqlsessionfactorybean 包括 datasource typeAliasesPackage configLocation
4. mapperscannerconfigurer dao

3.

最后再就是走到了更简单的spring注入整合mybatis，也就是用第三方类和配置类来代替bean配置。

那么datasource需要一个类， sqlsessionfactorybean需要一个类，mapperscannerconfigurer需要一个类。

所以最后我的案例就是最简单的spring注入整合mybatis如下：

3.3.Spring注解方式整合MyBatis具体操作

1.环境准备：

JDK:

Maven：

建立数据库表：

2.项目框架：

3.pom：

4.数据源的配置文件：MyBatis.properties:

这里注意连接词是&，还有时区是serverTimeZone=UTC

5.pojo类：

6.Mapper类

7.实现接口：

8.实现类：

9.Jdbc配置类：

10.Mybatis配置类：

11.核心最重要：Spring配置类 ！！！

12.测试类

13.测试结果：

4.AOP面向切面编程：

面向切面编程来源和概念：

首先还是来源是哪里，首先，在我们编写mybatis的时候，我们有一个mapper的类，而这个类最后是sqlsession返回的一个类，这个类的方法名对应着增删改查的操作步骤，可以总结为，mapper.xml文件对应了方法名，而这个mapper类执行对应的方法就是执行对应的sql语言，而sql语言也同样和方法一样，有一个输入和输出，输入就是模糊查询需要的字段，或者需要加入数据库的数据，而输出比如说是查询的结果。

总之：就是mapper.xml里面的 namespce = mapper.class

id = mapper.class里面对应的方法

就这样形成了一个对应，我们在通过sqlsession得到这个mapper的类的时候，我们操作这个类的方法其实就是操作

数据库的sql语句。

那么这个类这么重要，这个类对应了许多方法，那如果每个方法都有同样的代码，那我们就把他抽离出来，而

把这相同的代码叫做advice ， 所有的方法叫做 joinpoint，而需要用同一advice的方法就叫做pointcut，

最后advice + pointcut 就叫做 Aspect

Advice 的类型

before advice, 在 join point 前被执行的 advice. 虽然 before advice 是在 join point 前被执行, 但是它并不能够阻止 join point 的执行, 除非发生了异常(即我们在 before advice 代码中, 不能人为地决定是否继续执行 join point 中的代码)

after return advice, 在一个 join point 正常返回后执行的 advice

after throwing advice, 当一个 join point 抛出异常后执行的 advice after(final) advice, 无论一个 join point 是正常退出还是发生了异常, 都会被执行的 advice. around advice, 在 join point 前和 joint point 退出后都执行的 advice. 这个是最常用的 advice. introduction，introduction可以为原有的对象增加新的属性和方法。

所以每一次我们编写有很多jointpoint的方法的类的时候，我们需要把切面单独拿出来，这样

我们写代码就不会那么的浪费资源，同一advice可以有不用的pointcut使用。

而使用方法就是把pointcut和advice 写在一个切面类中，把这个类标注切面和bean最后被spring容器扫描从而

注入到容器里面即可。其他的实现类的步骤就按正常的从spring得到类的操作正常进行即可。

项目框架：

pom.xml

实现的接口 和实现的类如下：

接口：

实现类：

MyAdvice类的书写：

其实就是在aop的注解编程里面，其实可以把aop的切面当成一个类也是要放到bean容器里面

只是最后得到实现类的时候，调用实现类里面的方法时候会使用这个类的通知一并被调用。

但是值得注意的是这里的切点的标注是实现类的方法。

SpringBeanConfiguration的书写

这里注意这里的componentscan一定要把切面所在的类扫到。

客户类(使用类)

这里需要注意在getbean时候，这里放入的类不是实现类，而是接口类。这个地方和在切面类的切点的标注那里，都有点疑问，在后续学源码的时候再看看是什么原因。

运行结果：

5.Spring整合SpringMVC

很简单：四个大类：

SpringConfig类：

SpringMVC类：

ServletContainerIniti类：

SpringMVCConfig类：

到此这篇spring教程 csdn（spring教程菜鸟）的文章就介绍到这了,更多相关内容请继续浏览下面的相关推荐文章，希望大家都能在编程的领域有一番成就！

版权声明：

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如若内容造成侵权、违法违规、事实不符，请将相关资料发送至xkadmin@xkablog.com进行投诉反馈，一经查实，立即处理！

转载请注明出处，原文链接：https://www.xkablog.com/rfx/42113.html