spring framework-spring框架

已于 2023-02-10 21:50:23 修改
阅读量356 收藏 1
点赞数
文章标签： spring Powered by 金山文档
于 2023-02-10 20:47:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fhxjava/article/details/128976653
版权

问什么要学Spring框架

1.简化开发---->降低企业级开发的复杂性(简化IOC控制反转,AOP面向切面编程,事务处理)
2.框架整合---->高效整合其他技术，提高企业级应用开发与运行效率
//整合mybatis,mybatisplus

Spring核心思想

1.解耦合，提高编写的程序的扩展性/灵活性
  以前创建对象：new  构造方法  ，此方式耦合度非常高
//  实现的思想：
    spring提供一个spring 容器（一个对象：内部包含一个集合，此集合中可以存放各种java对象）
    spring可以帮助我们创建对象，不需要我们手动的通过new关键字创建对象
    获取对象，直接找spring框架要对象既可
 2.AOP面向切面编程，提供并实现了此思想，可以无入侵对代码功能进行增强
 3.方便的整合第三方更加优秀的框架
 4.提供了单元测试，方便测试
 5.申明式事务，只需要一个事务注解就可以实现对指定的方法进行事务控制
 6.内部体现了非常多的优秀的编程思想（学习一些优秀的设计理念/编程思想）
    学习spring的源码

Ioc和Di

.ioc-->控制反转:我不创建对象,spring创建
ioc:以前程序员主动new对象,现在由外部spring创建对象, 解耦合,
底层原理:spring解析配置文件,扫描注解,反射无参构造方法创建对象

附:IOC容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IoC容器中统称为-->Bean   javabean
2.DI-->依赖注入:

附:类于类之间的关系

1.代理  
2.聚合(依赖)
3.继承 
在容器中建立绑定bean与bean之间的依赖关系的整个过程，称为依赖注入
//  注入:为spring管理的类的成员变量赋值

最终效果

使用对象时不仅可以直接从IoC容器中获取，并且获取到的bean已经绑定了所有的依赖关系
bean
IOC容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IoC容器中统称为-->Bean
IOC入门问题
1. 管理什么？(Service与Dao)
2. 如何将被管理的对象告知IOC容器？(配置文件)
//   <bean id="BookDao" class="com.itheima.dao.impl.BookDaoImpl"></bean>
3. 被管理的对象交给IOC容器，如何获取到IoC容器？(接口)
4. IOC容器得到后，如何从容器中获取bean？(接口方法)
5. 使用Spring导入哪些坐标？(pom.xml)
*ioc和di的标签
//ioc中出现
 // <bean id="BookDao" class="com.itheima.dao.impl.BookDaoImpl"></bean>
//   <bean id="BookService" class="com.itheima.service.impl.BookServiceImpl">
bean标签：表示配置bean
id属性：表示给bean起名字,为了好记,写接口名
class属性：表示给bean定义类型,直接写到实现类


//di注入时出现的
//    <property name="bookDao" ref="BookDao"></property>
property标签：表示配置当前bean的属性
name属性：表示配置哪一个具体出现的属性,参照在service中的bookdao
ref属性：表示参照哪一个bean,写id的

附:bean 中 id是别名-->接口名   class-->直接具体实现了类
  property中 name-->具体在service出现的   ref-->是写id
//  附:在bean中没写scope  默认singleton单例  可以调整prototype非单例

使用Spring模式和不使用spring模式区别

1.不用spring模式

new对象

//创建正常maven项目-->创建dao层和service层 及app测试类
//dao接口
public interface BookDao {
    public void save();
}

//dao实现类
public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
}

//service接口
public interface BookService {
    public void save();
}

//service实现类
public class BookServiceImpl implements BookService {
    private BookDao bookDao = new BookDaoImpl();
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
}

测试app  
public class App {
    public static void main(String[] args) {
    //new service实现类 调用
        BookServiceImpl bookService = new BookServiceImpl();
        bookService.save();
    }
}

输出语句:正常输出打印dao和service的语句
book service save ...
book dao save ...

2.使用spring的IOC入门

spring创建对象

1.导入spring在pom文件的依赖

记得加个jdk版本的
  <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.7</maven.compiler.source>
        <maven.compiler.target>1.7</maven.compiler.target>
    </properties>




<dependencies>
        <!--导入spring的坐标spring-context，对应版本是5.2.10.RELEASE-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
    </dependencies>

2.在resources下创建applicationContext.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--
        bean标签：表示配置bean
        id属性：表示给bean起名字,为了好记,写接口名
        class属性：表示给bean定义类型,直接写到实现类
    -->
    <bean id="BookDao" class="com.itheima.dao.impl.BookDaoImpl"></bean>
    <bean id="BookService" class="com.itheima.service.impl.BookServiceImpl"></bean>

</beans>

3.创建app2测试类

public class App2 {
    public static void main(String[] args) {
        //1.创建配置类-->加载配置类
        ClassPathXmlApplicationContext ct = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2.获取bean对象  参数写application里面的id  类型转换
        BookService bookService = (BookService) ct.getBean("BookService");
        bookService.save();
    }
}

输出:
book service save ...
book dao save ...

使用spring好处

如果频繁修改测试app的BookDaoImp类
    不使用spring--->用自己new对象的方式,发现BookDaoImpl类名改变,测试类也需要修改代码
    用spring框架方式--->发现BookDaoImpl类名改变,测试类无需修改代码(只需要修改配置文件),完成解耦

3.DI入门案例

理解di思路
1. 基于IOC管理bean
2. Service中使用new形式创建的Dao对象是否保留？(否)
3. Service中需要的Dao对象如何进入到Service中？(提供set方法)
4. Service与Dao间的关系如何描述？(配置)  绑定DAO和Service关系 
//<property name="bookDao" ref="BookDao"></property>
property标签：表示配置当前bean的属性
name属性：表示配置哪一个具体的属性,参照在service中的bookdao 一般小写
ref属性：表示参照哪一个bean,写id的
实现步骤
【第一步】删除使用new的形式创建对象的代码
【第二步】提供依赖对象对应的setter方法
【第三步】在applicationContext配置service与dao之间的关系
代码实现

在service实现类中

public class BookServiceImpl implements BookService {
   // private BookDao bookDao = new BookDaoImpl();
    //1. 删除new方法  重写接口
   
    private BookDao bookDao;
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }

    //2.提供set方法
    //右键setter方法
   //spring框架会反射执行该方法,为成员变量赋值
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

在applicationContext.xml中 进行di注入

<?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标签：表示配置bean
        id属性：表示给bean起名字,为了好记,写接口名
        class属性：表示给bean定义类型,直接写到实现类
    -->
    <bean id="BookDao" class="com.itheima.dao.impl.BookDaoImpl"></bean>
    <bean id="BookService" class="com.itheima.service.impl.BookServiceImpl">
    <!--配置server与dao的关系
        property标签：表示配置当前bean的属性
        name属性：表示配置哪一个具体的属性,参照在service中的bookdao
        ref属性：表示参照哪一个bean,写id的
    -->
        <property name="bookDao" ref="BookDao"></property>
    </bean>
</beans>

4.bean实例化

(报错的话,从最后面看错误信息 ,上面都是一样的 从下往上看)

bean是如何创建出来的(bean的实例化三种方式)

bean本质是对象 ,以前都是有构造方法 在new bean(就是new 对象)

1.构造方法创建对象

spring创建bean对象 采用的是无参构造

例:在实现类中提供无参构造,如果写有参 必须写无参 ,不写无参和有参,默认无参

// 右键 generate-->constuctor 不选定方法->无参 选定方法-->有参

privateStudent(){}

publicStudent(){}

注意：无参构造方法如果不存在，将抛出异常BeanCreationException

2.静态工厂方式

使用静态方法-->静态工厂

了解

​

3 实例工厂方式

了解 资料有详细的

5.bean生命周期

bean创建到销毁的过程

6.DI注入方式

1.setter注入

提供set方法,spring框架会反射执行该方法,为成员变量赋值

2.构造方法注入

1.在serviceimpl设置有参构造和无参构造

2.提供set方法,spring框架会反射执行该方法,为成员变量赋值

7.自动装配依赖

自动创建对象 dao或者service

如果一个类是自动装配 的

1.则用spring获取该类的对象时,可以不指定id,直接指定类型即可

2.其成员变量会自动赋值,无需配置成员变量

app2

dao接口
public interface BookDao {
    public void save();
}

dao实现类
public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("book dao save ...");
    }
}

service接口
public interface BookService {
    public void save();
}

service实现类
public class BookServiceImpl implements BookService {
   // private BookDao bookDao = new BookDaoImpl();
    //1. 删除new方法  重写接口
    private BookDao bookDao;
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }

    public BookServiceImpl() {
    }

    //2.提供set方法
    //右键setter方法
    //spring框架会反射执行该方法,为成员变量赋值
   public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}



public class App2 {
    public static void main(String[] args) {
        //1.创建配置类-->加载配置类
        ClassPathXmlApplicationContext ct = new ClassPathXmlApplicationContext("applicationContext.xml");
        //2.获取bean对象  参数写application里面的id  类型转换
        /*BookService bookService = (BookService) ct.getBean("BookService");
        bookService.save();*/
        BookService bean = ct.getBean(BookService.class);   //通过类型找到对象
        System.out.println(bean);
        bean.save();


    }
}

applicationContext.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--
        bean标签：表示配置bean
        id属性：表示给bean起名字,为了好记,写接口名
        class属性：表示给bean定义类型,直接写到实现类
        autowire="byType" 直接自动装配  依赖注入
    -->
    <bean id="BookDao" class="com.itheima.dao.impl.BookDaoImpl"></bean>
    <bean id="BookService" class="com.itheima.service.impl.BookServiceImpl" autowire="byType">

第三方资源配置管理

1.管理DataSource的Druid和c3p0连接池

1. 管理Druid连接池

用set注入 德鲁伊和c3p0 在applicationContext.xml中的4大金刚(数据库名字,数据库路径,用户名,密码,)稍微不一样

  1. 【第一步】添加Druid连接池依赖
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.16</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>
注意：除了添加以上两个依赖之外，别忘了添加spring-context依赖
【第二步】配置DruidDataSource连接池Bean对象
注意id  测试类需要用
<beanid="dataSource"class="com.alibaba.druid.pool.DruidDataSource">
    <propertyname="driverClassName"value="com.mysql.jdbc.Driver"/>
    <propertyname="url"value="jdbc:mysql://localhost:3306/spring_db"/>
    <propertyname="username"value="root"/>
    <propertyname="password"value="320321"/>
</bean>
【第三步】在测试类中从IOC容器中获取连接池对象并打印
publicclassApp {
    publicstaticvoidmain(String[] args) {
        ApplicationContextctx=newClassPathXmlApplicationContext("applicationContext.xml");
        DataSourcedataSource= (DataSource) ctx.getBean("dataSource");
        System.out.println(dataSource);
    }
}
2.管理c3p0连接池
【第一步】添加c3p0连接池依赖
<dependency>
    <groupId>c3p0</groupId>
    <artifactId>c3p0</artifactId>
    <version>0.9.1.2</version>
</dependency>
【第二步】配置c3p0连接池Bean对象
<beanid="dataSource"class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <propertyname="driverClass"value="com.mysql.jdbc.Driver"/>
    <propertyname="jdbcUrl"value="jdbc:mysql://localhost:3306/spring_db"/>
    <propertyname="user"value="root"/>
    <propertyname="password"value="320321"/>
    <propertyname="maxPoolSize"value="1000"/>
</bean>
注意：同一个Spring容器中不能有两个id="dataSource"的连接池。
【第三步】在测试类中从IOC容器中获取连接池对象并打印
publicclassApp {
    publicstaticvoidmain(String[] args) {
        ApplicationContextctx=newClassPathXmlApplicationContext("applicationContext.xml");
        DataSourcedataSource= (DataSource) ctx.getBean("dataSource");
        System.out.println(dataSource);
    }
}

  1. 加载properties属性文件

大体思路
不要使用user name     系统默认是电脑自己的用户名字
1.加载第三方配置   //为了防止乱码写英文
2.创建接口
3.创建接口实现类  并加注解@data提供setget方法
4.创建applicatonContext.xml配置文件
(1.)通过
<context:property-placeholderlocation="sanguo.properties"system-properties-mode="NEVER"/>    获取beans
(2.)通过  propertyname和value${}获取键值
5.创建app测试类-->加载配置类-->通过接口.class获取bean-->输出
读取第三方配置文件案例
1.加载第三方配置文件 三国.proerties
junshi=zhugege
jaingju=Tom
zhugong=dogdog
  1. 创建dao
public interface SanGuo {
}
  1. 创建dao实现类
@Data  //注解 自动补全 get set 有参 空参 构造
public class SanGuoImpl implements SanGuo {
private String junshi;
private  String jiangjun;
private  String zhujun;
}
3.创建主配置文件

aplicationContext.xml

1.在配置文件中使用<propertyname="xxx"value=""></property> 加载第三方的name
​
2.引入第三方的 配置不加载系统属性
<context:property-placeholderlocation="jdbc.properties"system-properties-mode="NEVER"/>
​
3.使用${}获取第三方文件的value值
value="${junshi}"

完整的配置文件

<?xmlversion="1.0" encoding="UTF-8"?>
<beansxmlns="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">
​
​
<context:property-placeholderlocation="sanguo.properties"system-properties-mode="NEVER"/>
​
    <beanid="SanGuoImpl"class="com.itheima.dao.impl.SanGuoImpl">
        <propertyname="junshi"value="${junshi}"></property>
        <propertyname="zhujun"value="${zhugong}"></property>
        <propertyname="jiangjun"value="${jaingju}"></property>
    </bean>
​
</beans>
​
​
6.编写测试类
publicclassApp2 {
    publicstaticvoidmain(String[] args) {
        //1.创建配置类-->加载配置类
        ClassPathXmlApplicationContextct=newClassPathXmlApplicationContext("applicationContext.xml");
        //2.获取bean对象  参数写application里面的id  类型转换
        SanGuobean=ct.getBean(SanGuo.class);   //通过接口类找到对象
        System.out.println(bean);
    }
}
​
输出
SanGuoImpl(junshi=zhugege, jiangjun=Tom, zhujun=dogdog)
附加知识
<context:property-placeholder location="classpath*:*.properties"/>

fhxjava
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
spring框架详解（持续更新）
Ferao的博客
11-15 1万+
Mybatis Spring SpringMVC详解
Spring Framework框架（一）
weixin_44325527的博客
11-12 353
Spring Framework框架 一、Spring概述 1.spring 是什么 Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以 IoC（Inverse Of Control：反转控制）和 AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层 Spring MVC 和持久层 Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的 Java
系统架构——Spring Framework
最新发布
m0_74363339的博客
06-19 853
这篇博客主要是介绍了Spring中的最基础的一个核心——Spring Framework(系统架构)。介绍、发展历史以及 Spring 4.x 系列的系统架构的组成和介绍...
Spring框架简介
John Wong's Blog
09-28 793
Link: http://www.ibm.com/developerworks/cn/java/wa-spring1/ Spring模块功能如下： 核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC） 模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。Sp
Spring Framework
m0_64691190的博客
03-31 1005
关于Spring Spring框架主要解决了创建对象 管理对象的问题 在传统的开发中,当需要某个对象时,使用new关键字及类型的构造方法即可创建对象,例如: Random random =new Random(); 如果以上代码存在于某个方法中,则random就只是个局部变量,当方法运行结束,此变量就会被销毁 在实际项目开发,许多对象被创建出来之后,应该长期存在于内存中,而不应该销毁,当需要使用这些 对象时,通过某种方式获取对象即可,而不应该重新创建对象! 除了对象存在的时间(时长)以为,在
Springframework 框架
一路向前
04-08 310
Springframework 框架 由Spring Framework官网里面的Features 包括六大部分： 核心技术 测试 数据存取 MVC 协调 语言 模块之间是什么关系呢？ spring framework doc文档 从文档里面： 可以看到Spring Framework 框架描述 主要分成了5个部分。 再看下 spring framework在spring web中的应用： ...
Spring framework体系架构
weixin_30824479的博客
06-03 232
Spring3.x 图中将spring分为5个部分：core、aop、data access、web、test，图中每个圆角矩形都对应一个jar，如果在maven中配置，所有这些jar的“groupId”都是“org.springframework”，每个jar有一个不同的“artifactId”，另外，“instrumentation”有两个jar，还有一...
开发工具 框架JAR spring-framework-4.3.6.RELEASE-dist
05-31
开发工具 框架JAR spring-framework-4.3.6.RELEASE-dist开发工具 框架JAR spring-framework-4.3.6.RELEASE-dist开发工具 框架JAR spring-framework-4.3.6.RELEASE-dist开发工具 框架JAR spring-framework-4.3.6....
spring-framework-5.0.0.RELEASE-dist.zip
01-07
《Spring框架5.0.0.RELEASE：深度解析与应用》 Spring框架是Java开发中的一个核心组件，尤其在企业级应用开发中占据着举足轻重的地位。本压缩包"spring-framework-5.0.0.RELEASE-dist.zip"包含了Spring框架5.0.0....
spring-framework-5.3.8
04-10
总的来说，Spring Framework 5.3.8 是一个成熟的、强大的框架，适用于构建各种类型的企业级应用。通过持续的改进和优化，它确保了开发者可以利用最新技术和最佳实践进行开发。如果你正在使用或计划使用 Spring，了解...
spring-framework-5.3.20
06-13
Spring Framework，作为Java领域最广泛应用的轻量级框架之一，自诞生以来就以其卓越的灵活性、强大的功能和良好的社区支持，深受广大开发者的喜爱。本次我们将深入探讨Spring Framework的最新版本5.3.20，揭示其在...
springframework
04-23
java spring框架所需的核心包java spring框架所需的核心包java spring框架所需的核心包java spring框架所需的核心包
spring-framework-4.3.30.RELEASE-dist.zip
01-07
《Spring框架4.3.30.RELEASE：深入解析与应用》 Spring Framework是Java开发领域中的一个核心框架，以其模块化、松耦合和强大的依赖注入特性而闻名。本次我们关注的是Spring Framework的4.3.30.RELEASE版本，这是一...
Spring Framework系统架构
diaolove的博客
12-02 1004
Spring Framework是spring 里面的一个基础开源框架，主要用于javaee的企业开发。为现代系统提供了一个全面的编程和配置模型。基于Java的企业应用程序-在任何类型的部署平台上。截止于今天Spring Framework 已经开发到6.0版本。
Spring FrameWork学习笔记（一）Spring框架综述
放羊娃的记事本
10-10 1031
Spring框架为你开发企业级应用提供了一个轻量级的一站式解决方案。Spring是模块化的工具，允许你在不加入其他组件的情况下使用其中一个组件。你可以在任何web框架上使用IOC容器，你也可以只使用Hibernate集成模块或JDBC抽象层。Spring框架支持声明式的事务管理，支持通过RMI（Remote Method Invocation）或web service远程访问你的程序逻辑，支持通过
Spring Framework框架
weixin_46221109的博客
03-15 1249
概述 Spring Framework为现代基于Java的企业应用程序提供了全面的编程和配置模型 - 在任何类型的部署平台上。 Spring的一个关键要素是应用程序级别的基础架构支持：Spring专注于企业应用程序的“管道”，以便团队可以专注于应用程序级业务逻辑，而无需与特定部署环境建立不必要的联系。 支持政策和迁移 有关最低要求的信息，有关从早期版本升级和支持策略的指导，请查看Spring Fr...
spring Framework 框架
qq_45975759的博客
05-08 226
Spring Framework 1.ioc 控制反转依赖注入 2.aop 面向切面编程 3. dao 数据源（连接池），事务封装 4. mvc 接请求，返响应 Spring ioc inversion of control 控制反转 dependency injection 依赖注入 ioc全权管理项目中所使用到的对象，管理对象的生命周期（构建，装配，销毁） 控制反转：从主动获取对象的实例（ne...
spring framework-4.0.0
01-15
Spring Framework是一个开源的应用程序开发框架，4.0.0是其一个版本。Spring Framework以依赖注入（DI）和面向切面编程（AOP）为核心，旨在简化企业级Java应用程序的开发。 Spring Framework 4.0.0引入了许多新的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值