Spring+SpringMVC+MyBatis-教程、笔记-2

已于 2023-07-24 21:59:30 修改
阅读量76 收藏
点赞数
分类专栏： Spring+SpringMVC+MyBatis-教程-笔记 文章标签： spring mybatis 笔记
于 2023-07-24 21:21:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48269763/article/details/131905184
版权

base黑马，视频链接：https://www.bilibili.com/video/BV1WZ4y1P7Bp?t=94.4
此系列文章可以当做视频的配套笔记，也可以当做自学SSM框架的教程。

Spring配置数据源-数据源的作用

image.png
image.png

Spring配置数据源-数据源开发步骤

image.png

Spring配置数据源-数据源的开发步骤和手动创建C3P0数据源

1、导入相应的坐标

<dependency>
  <groupId>mysql</groupId>
  <artifactId>mysql-connector-java</artifactId>
  <version>5.1.32</version>
</dependency>

<dependency>
  <groupId>c3p0</groupId>
  <artifactId>c3p0</artifactId>
  <version>0.9.1.2</version>
</dependency>

<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>druid</artifactId>
  <version>1.2.10</version>
</dependency>

<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.11</version>
  <scope>test</scope>
</dependency>

2、创建测试类进行测试：

package com.lyh.test;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.junit.Test;
import java.sql.Connection;

public class DataSourceTest {

    //测试手动创建c3p0数据源
    @Test
    public void test1() throws Exception {
        //创建c3p0的对象
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        //设置基本的连接参数
        dataSource.setDriverClass("com.mysql.jdbc.Driver");
        dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/ssm1");
        dataSource.setUser("root");
        dataSource.setPassword("1234");
        //获取资源
        Connection connection = dataSource.getConnection();
        System.out.println(connection); //打印一下证明不是空的
        //关闭 表面上是关闭，实际上是归还
        connection.close();
    }
}

3、结果
image.png

Spring配置数据源-手动创建Druid数据源

1、导入相关的坐标，上面的例子中已经导入了
2、创建测试类进行测试

 //测试手动创建Druid数据源
    @Test
    public void test2() throws Exception {
        //创建Druid的对象
        DruidDataSource dataSource = new DruidDataSource();
        //设置基本的连接参数
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/ssm1");
        dataSource.setUsername("root");
        dataSource.setPassword("1234");
        //获取资源
        DruidPooledConnection connection = dataSource.getConnection();
        System.out.println(connection);
        //关闭 表面上是关闭，实际上是归还
        connection.close();
    }

3、结果
image.png

Spring配置数据源-抽取jdbc.properties文件

为了降低耦合度，创建配置文件 xx.properties，xx.xml文件也是可以的，但是xml文件的解析是比较费劲的。
在resources文件下面建立一个jdbc.properties文件（名字叫什么都行，a.properties、b.properties、c.properties）
image.png
这样是为了让具体的字符串设置与数据源解耦合。
jdbc.properties 文件中的内容

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/ssm1
jdbc.username=root
jdbc.password=1234

编写测试，在创建对象的时候读取properties配置文件

    //测试手动创建c3p0数据源(加载properties配置文件)
    @Test
    public void test3() throws Exception {
        //读取配置文件 用ResourceBundle 来 读取配置文件 ResourceBundle 是 java提供的工具
        //getBundle()需要的参数是 baseName 是基本名称，简称基名
        //getBundle()里面的参数 是 相对于 类加载路径的地址
        //在开发环境下就是相对于resources下面的路径
        //resources下面的内容 都在 类加载路径下
        //getBundle()需要的参数 不需要扩展名 因为 是 专门对 properties进行读取的
        //所以写jdbc就可以
        ResourceBundle resourceBundle = ResourceBundle.getBundle("jdbc");
        //进行赋值
        String driver = resourceBundle.getString("jdbc.driver");
        String url = resourceBundle.getString("jdbc.url");
        String username= resourceBundle.getString("jdbc.username");
        String password = resourceBundle.getString("jdbc.password");
        //创建数据源对象
        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
        //设置连接参数
        comboPooledDataSource.setDriverClass(driver);
        comboPooledDataSource.setJdbcUrl(url);
        comboPooledDataSource.setUser(username);
        comboPooledDataSource.setPassword(password);
        //获取资源
        Connection connection = comboPooledDataSource.getConnection();
        System.out.println(connection);
        //关闭资源，资源归还到数据源中
        connection.close();
}

结果：
image.png
抽取配置文件的目的是方便解耦，因为代码后期会进行编译，编译之后在打完的包中，看到的就是字节码文件，字节码文件是看不懂的，但是配置文件开发阶段长什么样子，最终还是长的什么样子。方便修改。

Spring配置数据源-Spring产生数据源对象

C3P0 或者 Druid 不是自己定义的，因为这个是导入第三方.jar包，像这种第三方的bean也是可以让Spring进行配置的。
Spring 是通过无参构造 帮忙创建对象，最简单的注入有set方法注入和有参构造注入。

//创建c3p0的对象
ComboPooledDataSource dataSource = new ComboPooledDataSource();
//设置基本的连接参数
dataSource.setDriverClass("com.mysql.jdbc.Driver");
dataSource.setJdbcUrl("jdbc:mysql://localhost:3306/ssm1");
dataSource.setUser("root");
dataSource.setPassword("1234");

上面的代码，正好满足通过Spring创建bean（对象）的条件
可以将DataSource的创建权交给Spring容器去完成
搭建Spring的环境
导入坐标

<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context</artifactId>
  <version>5.0.5.RELEASE</version>
</dependency>

创建配置文件   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 id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/ssm1"/>
    <property name="user" value="root"/>
    <property name="password" value="1234"/>
  </bean>
</beans>

测试代码：

    //测试Spring容器产生数据源对象
    @Test
    public void test4() throws Exception {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext1.xml");
        DataSource dataSource = applicationContext.getBean("dataSource",DataSource.class);
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
}

结果：
image.png
创建bean时，class里面内容的由来

Spring配置数据源-Spring加载properties文件

image.png
image.png

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

  <!--    加载外部的 properties文件-->
  <!--    引入context，目前而言通过context下面的标签加载-->
  <!--    要加载的文件 properties 在resources目录下 在类加载路径下 所以用 classpath-->
  <context:property-placeholder location="classpath:jdbc.properties"/>
  <!--    现在已经把 properties文件 加载到spring容器内部了-->
  
  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!--     这里用的是 spel、spring表达式 -->
    <property name="driverClass" value="${jdbc.driver}"/>
    <property name="jdbcUrl" value="${jdbc.url}"/>
    <property name="user" value="${jdbc.username}"/>
    <property name="password" value="${jdbc.password}"/>
  </bean>
</beans>

测试代码

    //Spring加载properties文件
    @Test
    public void test4() throws Exception {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext1.xml");
        DataSource dataSource = applicationContext.getBean("dataSource",DataSource.class);
        Connection connection = dataSource.getConnection();
        System.out.println(connection);
        connection.close();
}

结果：
image.png

Spring注解开发-原始注解介绍

image.png
image.png
image.png
image.pngimage.png

Spring注解开发-完善测试环境

创建Dao层的接口

package com.lyh.dao;

public interface UserDao {
    public void save();
}

创建Dao层的实现

package com.lyh.dao.impl;

import com.lyh.dao.UserDao;

public class UserDaoImpl implements UserDao {
    @Override
    public void save() {
        System.out.println("save方法执行了。。。");
    }
}

创建Service层的接口

package com.lyh.service;

public interface UserService {
    public void save();
}

创建Service层的实现

package com.lyh.service.impl;

import com.lyh.dao.UserDao;
import com.lyh.service.UserService;

public class UserServiceImpl implements UserService {

    private UserDao userDao;
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    @Override
    public void save() {
        userDao.save();
    }
}

创建Spring的配置文件

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

    <!--    加载外部的 properties文件-->
    <!--    引入context，目前而言通过context下面的标签加载-->
    <!--    要加载的文件 properties 在resources目录下 在类加载路径下 所以用 classpath-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--    现在已经把 properties文件 加载到spring容器内部了-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
      <property name="driverClass" value="${jdbc.driver}"/>
      <property name="jdbcUrl" value="${jdbc.url}"/>
      <property name="user" value="${jdbc.username}"/>
      <property name="password" value="${jdbc.password}"/>
    </bean>
  
    <bean id="userDao" class="com.lyh.dao.impl.UserDaoImpl"/>
    <bean id="userService" class="com.lyh.service.impl.UserServiceImpl">
      <property name="userDao" ref="userDao"/>
    </bean>

</beans>

创建UserController类

package com.lyh.web;

import com.lyh.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserController {
    public static void main(String[] args) {
        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext1.xml");
        UserService userService = app.getBean("userService",UserService.class);
        userService.save();
    }

}

结果：
image.png

Spring注解开发-原始注解入门操作

image.png Dao层里面的注解

package com.lyh.dao.impl;

import com.lyh.dao.UserDao;
import org.springframework.stereotype.Component;

//<bean id="userDao" class="com.lyh.dao.impl.UserDaoImpl"/>
@Component("userDao")
    public class UserDaoImpl implements UserDao {

        @Override
        public void save() {
            System.out.println("save方法执行了。。。");
        }
    }

Service层里面的注解

package com.lyh.service.impl;

import com.lyh.dao.UserDao;
import com.lyh.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;

//<bean id="userService" class="com.lyh.service.impl.UserServiceImpl">
@Component("userService")
    public class UserServiceImpl implements UserService {

        // <property name="userDao" ref="userDao"/>
        @Autowired//自动注入
        @Qualifier("userDao")
        private UserDao userDao;
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }

        @Override
        public void save() {
            userDao.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"
  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
  http://www.springframework.org/schema/context/spring-context.xsd">

    <!--    加载外部的 properties文件-->
    <!--    引context目前而言通过context下面的标签加载-->
    <!--    要加载的文件 properties 在resources目录下 在类加载路径下 所以用 classpath-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--    现在已经把 properties文件 加载到spring容器内部了-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
      <property name="driverClass" value="${jdbc.driver}"/>
      <property name="jdbcUrl" value="${jdbc.url}"/>
      <property name="user" value="${jdbc.username}"/>
      <property name="password" value="${jdbc.password}"/>
    </bean>
  
    <!--   虽然把注解配到这里了得告诉Spring-->
    <!--    组件扫描的作用是告诉Spring，
    在那个包下面的bean需要Spring进行扫描
    从而扫到对应的注解帮忙创建对象-->
    <!--    所以得配置组件扫描-->
    <context:component-scan base-package="com.lyh"/>
    <!--    扫描基础包 及其子包-->
</beans>

测试代码

package com.lyh.web;

import com.lyh.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserController {
    public static void main(String[] args) {

        ApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = app.getBean("userService",UserService.class);
        userService.save();
    }

}

效果：image.png

Spring注解开发-原始注解详解1

UserDaoImpl中注解的解释

package com.lyh.dao.impl;

import com.lyh.dao.UserDao;
import org.springframework.stereotype.Repository;

//<bean id="userDao" class="com.lyh.dao.impl.UserDaoImpl"/>
//@Component("userDao")
@Repository("userDao") //使用语意更加明确的 @Repository 注解 和 @Component作用一样 只是增加了语意
    public class UserDaoImpl implements UserDao {

        @Override
        public void save() {
            System.out.println("save方法执行了。。。");
        }
    }

UserServiceImpl中注解的解释

package com.lyh.service.impl;

import com.lyh.dao.UserDao;
import com.lyh.service.UserService;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

    //<bean id="userService" class="com.lyh.service.impl.UserServiceImpl">
    //@Component("userService")
    @Service("userService")
    public class UserServiceImpl implements UserService {

        // <property name="userDao" ref="userDao"/>
        //自动注入
        // 如果只是单独写上 @Autowired注解的话
        // 是按照数据类型从Spring容器中进行匹配的
        //当Spring扫描到这个注解之后 会 尝试着从 Spring容器中找一个UserDao类型的bean 直接注入
        //@Autowired
        //@Qualifier("userDao") //是按照 id值从容器中进行匹配 但是 此处@Qualifier要结合@Autowired一起使用
        @Resource(name="userDao") //网上有人说这个是jdk9的新特性 就是换到jdk8可以 但是 jdk11就不行
        //@Resource 就相当于 @Qualifier + @Autowired
        private UserDao userDao;
        //如果使用的是xml配置的方式 set方法是要写的
        //如果使用的是注解的方式 set方法可以省略不写
        //    public void setUserDao(UserDao userDao) {
        //        this.userDao = userDao;
        //    }

        @Override
        public void save() {
            userDao.save();
        }
    }

Spring注解开发-原始注解详解2

普通数据类型的注入：

	@Value("itcast")
    private String driver;

在applicationContext.xml配置文件中

<context:property-placeholder location="classpath:jdbc.properties"/>

加载外部的properties文件到Spring容器中，把properties的键值对放到了Spring容器中了

//spel表达式 直接到Spring容器中找对应的key，key如果匹配成功，就把key的值赋值给driver
	@Value("${jdbc.driver}")
    private String driver;

效果：
image.png
@Scope注解

	@Scope("prototype") //多例
    //@Scope("singleton") //单例
    public class UserServiceImpl implements UserService {
        
    }

创建 初始化方法 和 销毁方法 以及注解

	@PostConstruct //初始化注解 构造之后
    public void init(){
        System.out.println("Service对象的初始化方法。。。");
    }

	@PreDestroy //销毁方法 销毁之前
    public void destroy(){
    	System.out.println("Service对象的销毁方法。。。");
	}

测试

package com.lyh.web;

import com.lyh.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserController {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = app.getBean("userService",UserService.class);
        userService.save();
        app.close();
    }

}

效果：
image.png

Spring注解开发-新注解介绍

原始注解对于非自定义的bean就束手无策了。image.png
image.png

Spring注解开发-新注解详解

用核心配置类去替代.xml文件
核心配置类：SpringConfiguration

package com.lyh.config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.*;
import javax.sql.DataSource;
import java.beans.PropertyVetoException;

    //标志该类是Spring的核心配置类
    @Configuration
    //<context:component-scan base-package="com.lyh"/> 组件扫描
    @ComponentScan("com.lyh")
    //<import resource=""/>
    @Import({DataSourceConfiguration.class}) //加载分配置类
    //@Import({DataSourceConfiguration.class,XXX.class,XXX.class}) 可以是一个数组
    public class SpringConfiguration {
        

    }

DataSourceConfiguration配置类：

package com.lyh.config;

import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.PropertySource;
import javax.sql.DataSource;
import java.beans.PropertyVetoException;

    //<context:property-placeholder location="classpath:jdbc.properties"/>
    @PropertySource("classpath:jdbc.properties")
    public class DataSourceConfiguration {

        @Value("{jdbc.driver}")
        private String driver;
        @Value("{jdbc.url}")
        private String url;
        @Value("{jdbc.username}")
        private String username;
        @Value("{jdbc.password}")
        private String password;

        //Spring把这个方法的返回值给放到容器当中
        @Bean("dataSource") //Spring会将当前方法的返回值以指定名称存储到Spring容器当中
        public DataSource getDataSource() throws PropertyVetoException {
            //创建c3p0的对象
            ComboPooledDataSource dataSource = new ComboPooledDataSource();
            //设置基本的连接参数
            dataSource.setDriverClass(driver);//这里是API这里就是字符串
            dataSource.setJdbcUrl(url);
            dataSource.setUser(username);
            dataSource.setPassword(password);
            return dataSource;
        }

    }

测试代码：

package com.lyh.web;

import com.lyh.config.SpringConfiguration;
import com.lyh.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class UserController {
    public static void main(String[] args) {
        //ClassPathXmlApplicationContext app = new ClassPathXmlApplicationContext("applicationContext.xml");
        ApplicationContext app = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        UserService userService = app.getBean("userService",UserService.class);
        userService.save();
    }

}

效果：
image.png

Spring集成Junit-集成简介和开发步骤

image.png
image.png
image.png
Spring-test 包是用于Spring集成Junit包
@Runwith：原先进行测试的时候，是通过Junit进行测试的，而现在的测试是找Spring，Spring再帮我们去找Junit。

Spring集成Junit-代码实现

导入相关坐标

<!--    Junit的坐标-->
<dependency>
  <groupId>junit</groupId>
  <artifactId>junit</artifactId>
  <version>4.11</version>
  <scope>test</scope>
</dependency>

<!--Spring集成Junit的坐标-->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-test</artifactId>
  <version>5.0.5.RELEASE</version>
</dependency>

测试代码：
在这个文件夹下面才会生效，否则会报错
image.png

package com.lyh.web;

import com.lyh.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import javax.sql.DataSource;
import java.sql.SQLException;

//指定谁帮我去执行这个测试
	@RunWith(SpringJUnit4ClassRunner.class) //使用Spring提供的内核去跑
    @ContextConfiguration("classpath:applicationContext.xml") //指定配置文件的位置
    public class SpringJunitTest {
        //要测试谁 把谁进行注入就行
        @Autowired //直接进行注入就行，如果能注入成功就能测试它
        private UserService userService;

        @Autowired
        private DataSource dataSource;

        @Test
        public void test1() throws SQLException {
            userService.save();
            System.out.println(dataSource.getConnection());
        }

    }

效果：
image.png

package com.lyh.web;

import com.lyh.config.SpringConfiguration;
import com.lyh.service.UserService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import javax.sql.DataSource;
import java.sql.SQLException;

//指定谁帮我去执行这个测试
	@RunWith(SpringJUnit4ClassRunner.class) //使用Spring提供的内核去跑
    //@ContextConfiguration(value="classpath:applicationContext.xml") //指定配置文件的位置
    //使用全注解的方式
    //这个代表，现在要的不是配置文件。现在要的是一个配置类，把这个配置类的字节码告诉我
    @ContextConfiguration(classes={SpringConfiguration.class})//classes是一个数组方式
    public class SpringJunitTest {
        //要测试谁 把谁进行注入就行
        @Autowired //直接进行注入就行，如果能注入成功就能测试它
        private UserService userService;

        @Test
        public void test1() throws SQLException {
            userService.save();
            //System.out.println(dataSource.getConnection());
        }
    }
夏天的冬雪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring+SpringMVC+Mybatis SSM框架小项目
01-28
SSM框架，即Spring、SpringMVC和Mybatis的整合，是Java开发中常见的Web应用程序框架。这个开源小项目提供了一种便捷的方式，帮助初学者和有经验的开发者理解和实践这三个核心组件的集成。 首先，Spring框架是Java...
mybatis+spring+springMVC超级详细笔记
08-16
mybatis+spring+springMVC超级详细笔记，从入门到深入，到搭建SSM框架。 非常适合入门者参照学习，代码非常详细，理论知识全，条理清晰。 层次分明。
Java EE 框架整合 开发入门到实战-Spring+Spring MVC+MyBatis微课版复习笔记
06-05
Spring、Spring MVC和MyBatis是Java EE中最受欢迎的框架之一。这些框架的整合使用广泛用于构建企业级应用。下面将详细介绍这些框架的核心概念、模块组成、实例化Bean的方式以及依赖注入的机制和优势。 Spring框架...
【Spring+Mybatis+SpringMVC笔记】.zip
05-18
自己做的Spring+Mybatis+SpringMVC笔记------------------------------------------------------------------------------------------------------------------------ QQ：1017834057
SSM框架——详细整合教程（Spring+SpringMVC+MyBatis）.zip
07-03
本次为您带来的是最新的 Java 框架零基础从入门到精通的教程笔记项目，无论您是完全没有基础的小白，还是想要进一步提升的开发者，这套教程都将是您的理想之选。 教程内容丰富详实，涵盖了从基础知识的细致讲解，到...
《JavaEE进阶》----3.＜SpringBoot项目创建细节大全+打jar包运行＞
m0_73456341的博客
08-28 877
本篇博客讲解了创建Spring Boot项目的各种方法及创建细节、还有项目中目录和代码的简单介绍、启动项目、换端口号、Web服务器简介、HTTP状态码、以及用Maven打jar包运行
Spring Cache
m0_55956769的博客
08-26 440
Spring Cache
SpringBoot集成EasyExcel实现Excel文件导入/出
Lyhdreamer的博客
08-26 229
二，创建实体类 @ExcelProperty的属性 说明 value 按列名去匹配Excel数据，如果名字重复，会导致只有一个实体类字段读取到数据 index 按列的下标去匹配Excel数据
SpringBoot 注解指南
weixin_51582215的博客
08-23 723
基于 SpringBoot 平台开发的项目数不胜数，与常规的基于Spring开发的项目最大的不同之处，SpringBoot 里面提供了大量的注解用于快速开发，而且非常简单，基本可以做到开箱即用！那 SpringBoot 为开发者提供了多少注解呢？我们该如何使用？通常用于修饰controller层的组件，由控制器负责将用户发来的URL请求转发到对应的服务接口，通常还需要配合注解使用。提供路由信息，负责URL到Controller中具体函数的映射，当用于方法上时，可以指定请求协议，比如GETPOSTPUT。
SpringBoot 统⼀功能处理
最新发布
qq_74812898的博客
08-28 480
SpringBoot 统⼀功能处理
解决Spring的代理失效问题
初心不忘、始终方得
08-28 171
解决Spring的代理失效问题
springboot社区医疗服务系统--论文源码调试讲解
u014445459的博客
08-23 1095
刚开始学习Java语言的时候，是不知道还有Tomcat这些东西的，各种语法各种输出在控制台进行输出结果，当Java网站开发的时候就不可避免的学习到了Tomcat服务器。Tomcat准确的来讲不算是服务器，可以说是vue引擎或者一个容器，这些都是学术上或者原理上都比较贴切的，但是实际工作中Tomcat就是作为一个web服务器来用的，因为可以实现网站的发布和运行。420
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 363
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
高级java每日一道面试题-2024年8月25日-框架篇[Spring篇]-Spring框架中请举例解释@Required注解?
qq_43071699的博客
08-25 306
`@Required` 注解是Spring框架提供的一个标记注解，用于标记setter方法，以确保这些方法在Bean的初始化过程中必须被调用，即其对应的属性必须被注入值。如果Spring容器在初始化Bean时发现这个被`@Required`注解的setter方法没有被调用（即对应的属性没有被注入值），那么它将抛出一个`BeanInitializationException`异常。 这个注解主要用于手动依赖注入的场景，当你需要在Bean被创建后立即检查其依赖项是否已经被注入时。然而，在现代Spring应用程
【Spring】Spring循环依赖的解决方案
杰叔叔不是个好叔叔的博客
08-27 300
【Spring】Spring循环依赖的解决方案开篇词：干货篇：1.@PostConstruct方法：2.构造函数注入和Setter方法注入：3.配置文件注明【允许存在循环引用】4.@Lazy2.SpringUtil的getBean我是杰叔叔，一名沪漂的码农，下期再会！ 开篇词： 本篇不介绍循环依赖的简介和原理（想了解，自行百度哈），纯分享下解决方案。 ps：解决方案的优雅程度依次递增 干货篇： 1.@PostConstruct方法： @PostConstruct方法需要在Bean初始化后手动进行依赖注入
spring中的周期函数与模版方法模式
weixin_47503016的博客
08-28 155
spring中的周期函数与模版方法模式
Spring中的AopUtils
小湘西的博客
08-25 373
AopUtils是 Spring Framework 中一个工具类，位于包中。它提供了一系列静态方法，用于处理与面向切面编程（AOP）相关的操作。这些方法主要用于帮助开发人员进行 AOP 相关的操作，提供了一些便捷的工具，使得 AOP 的使用变得更加简单。
Spring如何既返回实体同时下载文件
编程思维
08-28 191
你可以将文件内容以Base64等方式编码后作为字符串嵌入到返回的实体中。客户端需要解码这个字符串以获取原始文件内容。这种方法适用于文件内容较小的情况。// 填充其他所需信息客户端收到响应后，需要解码这个字段来获取原始文件内容。
springboot中interceptor拦截器匹配URL源码
SmileAssassn的博客
08-23 305
看到在这里出现了拦截器，那么就在这个类里面往上找，打断点慢慢找，看看是在哪一步出现了拦截器。最后找到这里进行了拦截器的匹配模式。上一篇文章我们找到了filter过滤器的匹配源码，这次我们来找一下interceptor的匹配源码。直接源码里面备注里面就有写，那么两个都打上断点，调试一下即可。也可以用我之前写的文章，通过反编译jar包搜关键字的方式。接着翻调用链，看看从哪里开始出现拦截器的。同样先打断点看一下调用链。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值