Spring framework 入门

最新推荐文章于 2023-06-11 23:01:55 发布
最新推荐文章于 2023-06-11 23:01:55 发布
阅读量305 收藏
点赞数 1
文章标签： spring 5 java spring eclipse intellij idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/andyliu198571/article/details/118492023
版权

主要是对代码进行解耦和。

简介

spring源码是graddle构建

springframework 是spring 里面的一个基础开源框架，主要用于javaee的企业开发。Spring是什么呢？首先它是一个开源的项目，而且非常活跃；它是一个基于IOC和AOP构架的多层j2ee系统框架，但它不强迫你必须在每一层中必须使用Spring，因为它模块化的很好，允许你根据自己的需要选择使用它的某一个模块；它实现了很优雅的MVC，对不同的数据访问技术提供了统一的接口，采用IOC使得可以很容易的实现bean（普通的java类可以称为一个javaBean）的装配，提供了简洁的AOP(通过 创建代理对象实现对目标对象的功能扩展)并据此实现Transaction Management

full-stack :一站式开源框架。在web项目的各层都提供了解决方案

Spring是一个开源框架，它由Rod Johnson创建。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

Spring是一个一站式的轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。（单例）

控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。

面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的业务逻辑与系统级服务（例如审计（auditing）和事务（transaction）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。

容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。

框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。

所有Spring的这些特征使你能够编写更干净、更可管理、并且更易于测试的代码。它们也为Spring中的各种模块提供了基础支持。

spring版本

  • 3.x

支持java5

  • 4.x

支持java8

  • 5.x

去除java9依赖，支持高版本java

spring相关下载

版本：release snapshot

  • Spring体系架构

spring提供了web各层的解决方案，可以和当前主流的框架进行整合。

掌握

spring的核心框架：beans core context expression

eclipse安装STL(spring tool)插件

1. Spring IOC(invocation of control) 控制反转

将对象的创建权交给spring容器来管理。去new过程。

User user = new User();// 程序和User的耦合度较高
​
class UserService{
​
    UserDao dao = new UserDaoImpl();x
    UserDao dao = new UserDaoMybatisImpl();
    UserDao  dao = DaoFactory.getUserDao();
    
}

底层原理

总结：

IOC就是使用反射+配置文件+工厂模式，去除new关键字，将对象的创建权交给工厂来完成。

1.1 spring 入门环境搭建

    1. 创建java工程

    2. 引入spring的核心依赖：spring-beans.jar spring-core.jar spring-context.jar spring-expression.jar spring-jcl.jar(增加的spring的日志依赖)

    3. 创建配置文件

      <?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
          https://www.springframework.org/schema/beans/spring-beans.xsd">
  <!-- beans是顶层节点
  可以定义多个bean标签，标签和标签之间没有先后顺序
   -->        
   <!-- 
   id:唯一标识，不能出现特殊字符比如/
   class:控制反转需要的类的全限定类名
   name:名称，理论上可以重复，在实际开发过程中不允许重复
      可以出现特殊字符(/)
      在spring整合struts2时，name属性用于定义该请求的
      urlPattern
    -->
   <bean id="userDao"  class="com.sofwin.dao.impl.UserDaoImpl"></bean>
  </beans>

    • 测试

    package com.sofwin.test;
  
  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;
  
  import com.sofwin.dao.UserDao;
  
  public class Test01 {
    public static void main(String[] args) {
        // 工厂
        // ClassPathXmlApplicationContext
        // 是基于classpath下的配置文件生成的工厂（配置文件相对于classpath的位置）
        // a.xml
        // FileSystemXmlApplicationContext
        // 基于文件系统中的配置文件生成的工厂对象
        // C:\\A\a.xml
        // 在spring框架下可以出现多个配置文件
        ApplicationContext context =new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao dao = (UserDao)context.getBean("userDao");//通过name/id来获取对象
        dao.saveUser();
    }
  }
      
  

    面试问题

    ApplicationContext的区别BeanFactory

    1. 都是接口

    2. ApplicatonContex是BeanFactory的子接口

    3. 在单例模式下（默认bean标签使用的是单例）applicationContext在容器创建时，会实例化所有bean。BeanFactory只有在第一次getBean的时候才实例化对象。在多例模式下都是在getBean时实例化对象

1.2 普通bean IOC

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- beans是顶层节点
可以定义多个bean标签，标签和标签之间没有先后顺序
 -->        
 <!-- 
 id:唯一标识，不能出现特殊字符比如/
 class:控制反转需要的类的全限定类名
 name:名称，理论上可以重复，在实际开发过程中不允许重复
      可以出现特殊字符(/)
      在spring整合struts2时，name属性用于定义该请求的
      urlPattern
 scope:作用域
        默认是singleton 单例
        prototype  多例
        request   每次请求生成一个对象
        session 每次回话生成一个对象
        application
        websocket
  -->
 <bean id="userDao"  class="com.sofwin.dao.impl.UserDaoImpl" scope="prototype" ></bean>
​
</beans>

1.3 静态工厂 Bean IOC

工厂中创建实例的方法是静态方法

<!-- 
 静态方法的调用是类名.方法名
 factory-method：用于指定静态方法的方法名
 虽然class是工厂类型，但是getBean获取的实例应该是factory-method对应的
 方法的返回值类型
  --> 
  <bean id="userDao" class="com.sofwin.util.DaoFactory" factory-method="getUserDao"></bean>
​
package com.sofwin.util;
​
import com.sofwin.dao.UserDao;
import com.sofwin.dao.impl.UserDaoImpl;
​
public class DaoFactory {
    
    public static UserDao getUserDao() {
        return new UserDaoImpl();
    }
    public static UserDao getUserDao2() {
        return new UserDaoImpl();
    }
    public static UserDao getUserDao3() {
        return new UserDaoImpl();
    }
​
}
​

1.4 实例工厂Bean IOC

工厂中创建实例的方法是普通方法

<!-- 
  实例工厂的IOC需要分2步执行
  1.工厂IOC
   -->
   <bean id="factory" class="com.sofwin.util.DaoFactory">
   </bean>
   <!-- 
   2.指定调用某个工厂对象的某个方法
 factory-bean:用于指定工厂的id
 factory-method
    -->
    <bean id="userDao" factory-bean="factory" factory-method="getUserDao"></bean>
​

1.5 Bean的生命周期

  • 构造方法执行（实例化时）

  • 初始化方法执行（构造方法执行以后） init-method

  • 销毁方法 destroy-method

1.6 后处理Bean

是spring提供的用于监听容器中对象初始化的Bean。注意：该bean是直接由spring来调用的，不需要指定id，需要实现指定接口BeanPostProcessor

package com.sofwin.util;
​
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
​
public class SofwinBean implements BeanPostProcessor {
​
    /**
     * 初始化方法执行前执行
     * bean:监控到的bean
     */
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(bean);
        System.out.println(beanName);
        return bean;
    }
    /**
     * 初始化方法执行后执行
     */
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(bean);
        System.out.println(beanName);
        return bean;
        }
​
}
​
 <bean class="com.sofwin.util.SofwinBean"></bean>
​

1.7 基于annotation的IOC

第一类：用于替换xml中的bean标签 id class

第二类：用于定义生命周期的

注意

需要开启组件扫描，需要添加AOP依赖

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
          http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
<!-- 
增加context约束
    1.添加namespace  xmlns:context="http://www.springframework.org/schema/context"
    2.添加约束contxt.xsd
    开启组件扫描
    base-package:指定需要扫描的包
 -->
 <context:component-scan base-package="com.sofwin"></context:component-scan>
</beans>

一下注解都是类级别的注解，用于替换xml中的bean

id ：注解中的value属性对应的就是xml中的id,可以不写，类名首字母小写就是id

classpath:注解是类级别的注解

  • @Component（原生态注解）

衍生注解（除了@Controller其余的注解和@Component一样

  • @Controller

  • @Service

  • @Repository

注解适用于开发过程中自定义Bean的处理。xml用于开发中第三方架构的Bean的处理

init-method:@PostConstructor

destroy-method:@PreDestroy

1.8 DI(Dependency injection)

依赖注入必须使用IOC的环境，依赖的双方都必须交给spring管理

extend

has a

use a 依赖

contains a

Class A中用到了Class B的对象b，一般情况下，需要在A的代码中显式的new一个B的对象。

采用依赖注入技术之后，A的代码只需要定义一个私有的B对象，不需要直接new来获得这个对象，而是通过相关的容器控制程序来将B对象在外部new出来并注入到A类里的引用中。而具体获取的方法、对象被获取时的状态由配置文件（如XML）来指定。 [1]

class A{
​
B b;
C c;
​
}
// 不关注A,B,C对象的生成过程（容器来生成的）
// 不关注b的注入过程

1.8.1 基于xml的依赖注入

简单类型的依赖注入

  • setter方法注入

可以属性，并且包含有公有的setter方法的属性依赖注入到对象中

<?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 definitions here -->
<bean id="user" class="com.sofwin.pojo.User">
<!-- 
setter方法注入
name:属性的属性名
value:简单类型的值
ref:引用地址（bean的id），被引用的实体类的bean的id
 -->
 <property name="id" value="100"></property>
 <property name="name" value="100admin"></property>
 <property name="dept" ref="dept"></property>
</bean>
<bean id="dept" class="com.sofwin.pojo.Dept">
    <property name="id" value="110"></property>
    <property name="name" value="deptName"></property>
</bean>
</beans>
Class userClass = Class.forName("");
Object obj = userClass.newInstance();
String methodName ="setId";
Method m = userClass.getDeclaredMethod(methodName,)
m.invoke(obj,100);

  • 构造方法注入

可以重载构造方法，依赖的对象通过构造方法注入

<?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 definitions here -->
<bean id="user" class="com.sofwin.pojo.User">
<!-- 
用于指定构造方法的输入值
name:构造方法中形参名称
type:指定形参类型（可以省略）
index:代表参数的索引  （name二选一）
value：实参
ref
 -->
<constructor-arg index="0" type="java.lang.String" value="100"></constructor-arg>
<constructor-arg index="1" type="java.lang.String" value="admin"></constructor-arg>
</bean>
<bean id="dept" class="com.sofwin.pojo.Dept">
    <property name="id" value="110"></property>
    <property name="name" value="deptName"></property>
</bean>
</beans>

  • P命名空间注入

  1. 在配置文件中构建p命名空间

<?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"
    xmlns:p="http://www.springframework.org/schema/p"
    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 definitions here -->
    <!-- 
    由于p命名空间无法检测属性的类型 
    p:属性名=简单数据类型
    p:属性名-ref=引用数据类型注入
     -->
<bean id="user" class="com.sofwin.pojo.User" p:id="100" p:name="admin" p:dept-ref="dept">
</bean>
<bean id="dept" class="com.sofwin.pojo.Dept">
    <property name="id" value="110"></property>
    <property name="name" value="deptName"></property>
</bean>
</beans>

  • SPEL表达式注入

#{变量}

#{表达式}

#{对象.属性}

   
 <!-- bean definitions here -->
    <!-- 
    由于p命名空间无法检测属性的类型 
    p:属性名=简单数据类型
    p:属性名-ref=引用数据类型注入
     -->
<bean id="user" class="com.sofwin.pojo.User" p:id="#{dept.id}" p:name="admin" p:dept-ref="dept">
</bean>
<bean id="dept" class="com.sofwin.pojo.Dept">
    <property name="id" value="#{T(java.lang.Math).random*100}"></property>
    <property name="name" value="deptName"></property>
</bean>

引用类型的依赖注入

  • setter方法注入

  • 构造方法注入

<?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 definitions here -->
<bean id="user" class="com.sofwin.pojo.User">
<!-- 
用于指定构造方法的输入值
name:构造方法中形参名称
type:指定形参类型（可以省略）
index:代表参数的索引  （name二选一）
value：实参
ref:用于引用的id
 -->
<constructor-arg index="0" ref="dept"></constructor-arg>
</bean>
<bean id="dept" class="com.sofwin.pojo.Dept">
    <property name="id" value="110"></property>
    <property name="name" value="deptName"></property>
</bean>
</beans>

  • P命名空间注入

  • SPEL表达式注入

其他类型的依赖注入

在整合其他第三方架构时，需要使用

  • list

    <!-- 
    用于注入list属性的
     -->
    <list>
    <!-- 
    list中增加简单类型的数据
     -->
        <value>1</value>
        <value>2</value>
        <value>3</value>
    </list>
    
    <!-- 
    用于注入list属性的
     -->
    <list>
    <!-- 
    ref:
    bean用于放引用类型的bean的id
     -->
        <ref bean="dept"/>
        <ref bean="dept"/>
    </list>

  • array

 <array>
            <value>1</value>
            <value>2</value>
            <value>3</value>
            <!-- 
            自定义pojo类型的数组  ref  bean 
             -->
            <ref/>
        </array>

  • properties

注意

.properties配置文件 key=value key和value都 不能使用“” jdbc.userName=root

    <property name="pros">
    <props>
        <prop key="userName">admin</prop>
            <prop key="userName1">admin1</prop>
                <prop key="userName2">admin2</prop>
    </props>
    </property>

  • map

<property name="map">
    <map>
    <!-- 
    一个键值对
    key:简单类型的key
    key-ref:引用类型的key对应的bean id
    value:简单类型的值
    value-ref:引用类型的值对应的bean id
     -->
    <entry key="name" value="admin"></entry>
    <entry key="name1" value-ref="dept"></entry>
    <entry key-ref="dept" value="admin2"></entry>
    <entry key-ref="dept" value-ref="dept"></entry>
    </map>

1.8.2 基于annotation的依赖注入

  1. 开启组件扫描

注解

１.　＠value

注入简单类型的属性

属性级别：

方法级别

参数级别

package com.sofwin.pojo;
​
import java.util.List;
import java.util.Map;
import java.util.Properties;
​
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public class User {
    // 简单类型的属性的依赖注入可以将@Value注解写在
    // 属性中也可以将@Value写在setter方法上
    @Value(value="1000")
    private Integer id;
    @Value(value="admin")
    private String name;
    private Integer age;
    private String pwd;
    
    
    private List<Integer> ids;
    
    private List<Dept> depts;
    
    private Integer[] array;
    
    
    private Properties pros;
    
    private Map map;
    
    private Dept dept;// 用户所属部门
​
    public Map getMap() {
        return map;
    }
​
    
    public void setMap(Map map) {
        this.map = map;
    }
​
​
    public void setDepts(List<Dept> depts) {
        this.depts = depts;
    }
​
​
​
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getPwd() {
        return pwd;
    }
    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
    public Dept getDept() {
        return dept;
    }
    public void setDept(Dept dept) {
        this.dept = dept;
    }
​
​
    public List<Integer> getIds() {
        return ids;
    }
​
​
    public void setIds(List<Integer> ids) {
        this.ids = ids;
    }
​
​
    public Integer[] getArray() {
        return array;
    }
​
​
    public void setArray(Integer[] array) {
        this.array = array;
    }
​
​
    public List<Dept> getDepts() {
        return depts;
    }
​
​
    public Properties getPros() {
        return pros;
    }
​
​
    public void setPros(Properties pros) {
        this.pros = pros;
    }
    
    
​
​
}
​

  1. 按类型注入

@Autowired（自动装配）

// ref
    // 在注入时按照类型注入
    // 容器中不能出现多个同种类型的对象
    @Autowired
    private Dept deptsfd;// 用户所属部门
    
    @Autowired(required = false)
    private UserDao dao;

  1. 按名称注入

@Resource

装配机制：默认按照名称注入（属性名为需要注入的bean的id)，如果按名称没有注入成功，按类型注入，并且可以强制使用按什么注入

    // name指定注入的bean的id
    @Resource
    private UserDao userDaoImplsxxx;
​

组合注解

@Autowird

@Qualifer

@Autowired
    @Qualifier("userDaoImpl")
    private UserDao userDaoImplsxxx;
_AndyLau
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring框架学习
qq_53957101的博客
09-30 2061
spring学习框架（简写）
http://www.springframework.org/schema/context/spring-context-3.2.xsd
专注于大数据方向，区块链，前后端，数据可视化，人工智能等领域
12-02 4226
使用eclipse,spring-mvc 配置文件时报错。 cvc-complex-type.2.4.c: The matching wildcard is strict, but no declaration can be found for eleme …… 解决方法是： （1）项目采用maven进行jar包的管理，项目可能在本地找不到对应的文件。可用到本地maven库中找到spring-co
Spring学习笔记(四)--spring配置文件schema约束
热门推荐
至尊宝
01-16 3万+
强烈推荐一个大神的人工智能的教程：http://www.captainbed.net/zhanghan 相关概念 在使用spring的配置文件时,新添加一个配置文件就需要添加相应的约束,一直没有研究过为什么要有这些约束,这些约束是干什么的。spring在启动的时候需要验证xml文档,约束的作用就是来验证配置文件的xml文档语法的正确性。 在项目中其中的一个spring配置文件约...
无法读取方案文档 'http://www.springframework.org/schema/beans/spring-beans.xsd'问题解决
qq_40901379的博客
09-26 5739
找到xml文件中的xsi:schemaLocation（本地仓库） "http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.1.xsd“ 有这样子的东西 他会提示你找不到beans文件之类的，其他文件也同理 具体解决办法如下： 下载dtd文件到某个...
Spring framework（一）概述
全栈攻城狮JSON的博客
11-28 1万+
一、Spring framework 即Spring,是其他Spring全家桶的基础和核心：包括SpringMVC、SpringBoot、SpringCloud、SpringData、SpringSecurity。 Spring由Rod Johnson创立，2004年发布了Spring框架的第一版，其目的是用户简化企业级开发的难度和周期。 1.1、核心 Spring是分层的JavaSE/EE一站式轻量级开源框架，以IoC（Inverse of Control，控制反转）和AOP（Aspect Oriente
Spring Framework 5.0 入门教程
08-27
Spring Framework提供了一个简易的开发方式，这种开发方式，将避免那些可能致使底层代码变得繁杂混乱的大量的属性文件和帮助类。这篇文章主要介绍了Spring Framework 5.0 入门教程,感兴趣的小伙伴们可以参考一下
SpringFramework5.0入门篇
02-24
SpringFramework是一个开源的Java／JavaEE全功能栈（full-stack）的应用程序框架，以Apache许可证形式发布，也有.NET平台上的移植版本。该框架基于ExpertOne-on-OneJavaEEDesignandDevelopment（ISBN0-7645-4385-7）...
spring framework入门(11)：springmvc简易环境搭建
07-26
spring framework入门(11)：springmvc简易环境搭建 博客：https://blog.csdn.net/u010476739/article/category/7077919
Spring Framework 5 中文文档
10-20
1. 入门指南 2. 介绍Spring框架 3. IoC容器 4. 资源 5. 验证、数据绑定和类型转换 6. Spring表达式语言 9. Spring框架下的测试 10. 单元测试 11. 集成测试 14. DAO支持 15.使用JDBC实现数据访问 16. ORM和数据访问 ...
Spring 框架（Spring Framework）使用详解
墨鸦的博客
08-09 1万+
Spring 框架（Spring Framework）使用详解
Spring Framework概述及入门案例
m0_52319305的博客
05-08 1919
Spring 是最受欢迎的企业级 Java 应用程序开发。Spring 框架是一个开源的 Java 平台，它最初是由 Rod Johnson 编写的，并且于 2003 年 6 月首次在 Apache 2.0 许可下发布。Spring 是轻量级的框架，其基础版本只有 2 MB 左右的大小。Spring 框架的核心特性是可以用于开发Java 应用程序，但是在 Java EE 平台上构建 web 应用程序是需要扩展的。
springmvc.xml文件中出现名称空间xmlns:context=“http://www.springframework.org/schema/context“报红的解决方法
码农研究僧的博客
10-31 4334
在idea编译器中 在sprigmvc.xml的名称空间里 出现http://www. springframework.org/schema/tx报红 如图所示： 第一个方法是让编译器自动查找 可以通过此处的Fetch external resource 可能好转也可能不为所动 类似下面这种提示 表示找不到 那就需要手动进行添加该路径 通过编译器的设置进行添加 通过如下 点击＋号添加http://www. springframework.org/schema/tx 之后显示就无异常 ...
SpringFramework概述，先认识一下SpringFramework
weixin_46281472的博客
03-13 1987
目录 1、Spring的官网 2、正式介绍SpringFramework 1、Spring的官网 我本人一直都认为，学任何东西都应该尽量的从根上开始学起；Spring作为一个目前而言JAVA后端很流行的一个开源框架，它是有官网的，下面是它的官网地址（可以直接在百度上搜 Spring官网就可以）： Spring | Homehttps://spring.io/打开的会慢一点，下面就是它的官网的界面： 其实我们还是尽量看英文吧，看的习惯了其实觉得就好了，就像使用IDEA一样，起初总想做个
Spring Framework系统架构
diaolove的博客
12-02 978
Spring Framework是spring 里面的一个基础开源框架，主要用于javaee的企业开发。为现代系统提供了一个全面的编程和配置模型。基于Java的企业应用程序-在任何类型的部署平台上。截止于今天Spring Framework 已经开发到6.0版本。
Spring Framework 基础入门
从零开始的博客
07-15 4133
/方式一类路径加载配置文件ApplicationContextcontext=newClassPathXmlApplicationContext("applicationContext.xml");//加载多个配置文件context=newClassPathXmlApplicationContext("applicationContext.xml,applicationContext2.xml");//方式二httpshttpshttpshttpshttpshttps。......
SpringFramework教程
weixin_46081816的博客
02-24 3184
SpringFramework教学 官网地址：https://spring.io/projects/spring-framework 简述：Spring Framework 为基于 Java 的现代企业应用程序提供了一个全面的编程和配置模型——在任何类型的部署平台上。 Spring 的一个关键元素是应用程序级别的基础设施支持：Spring 专注于企业应用程序的“管道”，因此团队可以专注于应用程序级别的业务逻辑，而无需与特定部署环境建立不必要的联系。 一、核心内容 ​ Spring Framework有两个核
初识springframework
m0_65431718的博客
04-30 2127
初识java框架
02-Spring FrameWork 系统架构
记录java学习日常~
06-11 132
1. 核心容器（Core Container）：提供了IoC（Inversion of Control）容器和AOP（Aspect Oriented Programming）框架。IoC容器可以帮助我们管理对象之间的依赖关系，而AOP框架则可以让我们以声明式方式实现横切关注点的编程，例如日志、事务等。4. AOP模块：提供了对AOP编程的支持，可以让我们在方法执行前、执行后、抛出异常时等关键点进行切面处理。5. 测试模块（Testing）：提供了一些测试相关的类和工具，可以方便地进行单元测试和集成测试。
Spring Framework【框架概述】
CS5686的博客
06-19 622
框架概述
spring framework.jar
最新发布
01-01
Spring Framework.jar是一个开源的Java应用程序框架。它提供了一个全面的基础架构，用于构建企业级应用程序和Web应用程序。Spring Framework.jar的核心理念是轻量级和松散耦合，使开发人员能够更轻松地构建可扩展、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值