Spring

已于 2023-12-27 21:47:14 修改
阅读量30 收藏
点赞数
分类专栏： java前后端学习 # javaweb 文章标签： spring java log4j
于 2023-09-23 16:36:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaolitongxue12_/article/details/132630621
版权

1.Spring Framework架构

  1. Core Container：核心容器
  2. AOP：面向切向编程
  3. Aspects：AOP思想实现
  4. Data Access：数据访问  Data Intergation：数据集成
  5. Web：Web开发
  6. Test：单元测试与集成测试

2.Spring Framework学习路线

3.核心概念

代码现状：耦合度偏高。

解决方案：使用对象时，在程序中不要主动使用new产生对象，转为由外部提供对象。

Ioc控制反转：对象的创建控制权由程序转移到外部（主动new对象转为由外部提供对象），这种思想称为控制反转。

Spring技术对IOC思想进行了实现：

        Spring提供了一个容器，用来充当IoC思想中的“外部”。

        IoC容器负责对象的创建、初始化等一系列工作，被创建或被管理的对象在IoC容器中统称为Bean。

DI依赖注入：在容器中建立Bean和Bean之间的依赖关系的整个过程称为Bean依赖

目标：充分解耦

        使用IoC容器管理Bean。

        在IoC容器内将有依赖关系的bean进行关系绑定（DI）

最终效果：使用对象时不仅可以直接从IoC容器中获取，并且获取到的bean已经绑定了所有的依赖关系。

4.IoC入门案例（XML版本）

1.管理什么？（Service与Dao）

2.如何将被管理的对象告知IoC容器？（配置）

3.被管理的对象交给IoC容器，如何获取到IoC容器？（接口）

4.IoC容器得到后，如何从容器中获取Bean？（接口方法）

5.使用Spring导入哪些坐标？（pom.xml）

步骤：

        1.导入Spring坐标

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

        2.定义Spring管理的类（接口）

public interface BookService {
    void save();
}


public class BookServiceImpl implements BookService {
    BookDao bookDao = new BookDaoImpl();
    @Override
    public void save() {
        bookDao.save();
    }
}

        3.创建Spring配置文件，配置对应类作为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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
<!--        1.导入Spring坐标spring-context-->
<!--        2.配置Bean-->
<!--    id属性表示给Bean起名字-->
<!--    class属性表示给Bean定义类型-->
    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" />
    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" />
</beans>

        4.初始化容器，通过容器获得Bean

public class App {
    public static void main(String[] args) {
        //3.获取IoC容器
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        //4.获取Bean
        BookService bookService = (BookService) ctx.getBean("bookService");
        bookService.save();


    }
}

5.DI入门案例

1.基于IoC管理Bean

2.Service中使用new形式创建Dao对象是否保留？（否）

3.Servcie中需要的Dao对象如何进入Service中？（提供方法）

4.Service与Dao间的关系如何描述？（配置）

步骤：

        1.删除使用new的形式创建的代码

        2.提供依赖对象对应的set方法

public class BookServiceImpl implements BookService {
    //5.删除业务层中使用new方法创建的dao对象
    BookDao bookDao;
    @Override
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    //6.提供对应的set方法

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

        3.配置Service与Dao的关系

    <bean id="bookService" class="com.itheima.service.impl.BookServiceImpl" >
<!--        7.配置server与dao的关系-->
<!--        property标签表示配置当前Bean的属性-->
<!--        name属性表示配置哪一个具体的属性-->
<!--        ref属性表示参照哪一个Bean-->
        <property name="bookDao" ref="bookDao"/>

6 bean基础配置

6.1 bean的别名配置（name属性）

6.2 bean的作用范围（scope属性）

适合交给容器管理的bean：

  • 表现层对象
  • 业务层对象
  • 数据层对象
  • 工具对象

不适合交给容器管理的bean：封装实体的域对象

7.bean实例化

7.1 Bean是如何创建的

1.构造方法实例化Bean（常用）

2.使用静态工厂实例化Bean

public class BookDaoFactory {
    public static BookDao getBookDao(){
        return new BookDaoImpl();
    }
}



<bean id="bookDao2" class="com.itheima.factory.BookDaoFactory" factory-method="getBookDao" />

3.实例工厂初始化Bean

public class UserDaoFactory {
    public UserDao getUserDao(){
        return new UserDaoImpl();
    }
}


    <bean id="userDaoFactory" class="com.itheima.factory.UserDaoFactory" />
    <bean id="userDao" factory-bean="userDaoFactory" factory-method="getUserDao"/>

3-1 使用FactoryBean实例化Bean

public class UserDaoFactoryBean implements FactoryBean<UserDao> {
    @Override
    public UserDao getObject() throws Exception {
        return new UserDaoImpl();
    }

    @Override
    public Class<?> getObjectType() {
        return UserDao.class;
    }
}


    <bean id="userDao" class="com.itheima.factory.UserDaoFactoryBean" />

8.Bean的生命周期

初始化容器：

  1. 创建对象（内存分配）
  2. 执行构造方法
  3. 执行属性注入（set操作）
  4. 执行Bean初始化方法

使用Bean：执行业务操作

关闭/销毁容器：执行Bean销毁

方法一：配置生命周期控制方式

public class BookDaoImpl implements BookDao {
    @Override
    public void save() {
        System.out.println("dao save ...");
    }

    public void init(){
        System.out.println("bookdao init");
    }

    public void destory(){
        System.out.println("bookdao destory");
    }
}




    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl" init-method="init" destroy-method="destory" />

方法二：实现接口

public class BookServiceImpl implements BookService, InitializingBean, DisposableBean {
    //5.删除业务层中使用new方法创建的dao对象
    BookDao bookDao;
    @Override
    public void save() {
        System.out.println("book service save ...");
        bookDao.save();
    }
    //6.提供对应的set方法

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    @Override
    public void destroy() throws Exception {
        System.out.println("service destory");
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("service init");
    }
}

9.依赖注入方式

依赖注入方式：

  • setter注入：简单类型、引用类型
  • 构造器注入：简单类型、引用类型

9.1 setter注入简单类型：

public class BookDaoImpl implements BookDao {
    private int ConnectionNum;
    private String databaseName;

    public void setConnectionNum(int connectionNum) {
        ConnectionNum = connectionNum;
    }

    public void setDatabaseName(String databaseName) {
        this.databaseName = databaseName;
    }

    @Override
    public void save() {
        System.out.println("dao save ..."+ConnectionNum +" "+databaseName);
    }
    
}


    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <property name="connectionNum" value="10" />
        <property name="databaseName" value="mysql"/>
    </bean>

9.2 setter注入引用类型（见5 DI入门案例）

9.3 构造注入引用类型

public class UserDaoImpl implements UserDao {
    private BookDao bookDao;

    public UserDaoImpl(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    public UserDaoImpl() {
    }

    @Override
    public void save() {
        System.out.println("userdao save ...");
    }
}



    <bean id="userDao2" class="com.itheima.dao.impl.UserDaoImpl">
        <constructor-arg name="bookDao" ref="bookDao"/>
    </bean>

9.4 构造注入普通类型

    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <constructor-arg name="connectionNum" value="10"/>
        <constructor-arg name="databaseName" value="hh"/>
    </bean>

9.5 优化name属性造成的高耦合：index属性（使用位置来表示属性）

    <bean id="bookDao" class="com.itheima.dao.impl.BookDaoImpl">
        <constructor-arg index="0" value="10"/>
        <constructor-arg index="1" value="hh"/>
    </bean>

9.6 依赖注入选择

10.依赖自动装配

10.1 演示案例

        byType自动装配，要求：

  1. 装配的类只能有一个Bean
  2. 必须要有Setter方法
public class PeopleImpl implements PeopleDao {

    private UserDao userDao;

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

    @Override
    public void save() {
        System.out.println("PeopleDao is save...");
        System.out.println("userDao已注入:"+userDao);
    }
}



    <bean id="peopleDao" class="com.itheima.dao.impl.PeopleImpl" autowire="byType"/>

10.2 依赖自动装配特征

  1. 自动装配用于引用类型依赖注入，不能对简单类型注入
  2. 使用按类型装配时（byType）必须保障容器中相同类型的Bean唯一，推荐使用
  3. 使用按名称装配时（byName）必须保障容器中具有制定名称的Bean，有耦合不建议使用
  4. 自动装配优先级低于setter注入和构造器注入，同时出现时自动装配失效

11.集合注入

public class HhImpl implements hhDao {
    private int[] array;
    private List<String> list;
    private Set<String> set;
    private Map<String ,String> map;
    private Properties properties;

    public void setArray(int[] array) {
        this.array = array;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    @Override
    public void save() {
        System.out.println("HH dao save ...");
        System.out.println("遍历数组:"+ Arrays.toString(array));
        System.out.println("遍历List:"+ list);
        System.out.println("遍历set:"+set);
        System.out.println("遍历map"+map);
        System.out.println("遍历Properties"+properties);
    }
}
 


   <bean id="hhDao" class="com.itheima.dao.impl.HhImpl">
        <property name="array">
            <array>
                <value>1</value>
                <value>1</value>
                <value>3</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>1</value>
                <value>1</value>
                <value>3</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>1</value>
                <value>1</value>
                <value>3</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="country" value="China"/>
                <entry key="province" value="henan"/>
                <entry key="city" value="kaifeng"/>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="country">China</prop>
                <prop key="province">hennan</prop>
                <prop key="city">kaifeng</prop>
            </props>
        </property>
    </bean>

12.第三方资源配置管理

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
        <property name="url" value="jdbc::mysql://localhost:3306/book" />
        <property name="username" value="root" />
        <property name="password" value="123456" />
    </bean>

13 集合对象和properties文件的加载

13.1 集合对象

public class HhImpl implements hhDao {
    private int[] array;
    private List<String> list;
    private Set<String> set;
    private Map<String ,String> map;
    private Properties properties;

    public void setArray(int[] array) {
        this.array = array;
    }

    public void setList(List<String> list) {
        this.list = list;
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    @Override
    public void save() {
        System.out.println("HH dao save ...");
        System.out.println("遍历数组:"+ Arrays.toString(array));
        System.out.println("遍历List:"+ list);
        System.out.println("遍历set:"+set);
        System.out.println("遍历map"+map);
        System.out.println("遍历Properties"+properties);
    }
}
  
  <bean id="hhDao" class="com.itheima.dao.impl.HhImpl">
        <property name="array">
            <array>
                <value>1</value>
                <value>1</value>
                <value>3</value>
            </array>
        </property>
        <property name="list">
            <list>
                <value>1</value>
                <value>1</value>
                <value>3</value>
            </list>
        </property>
        <property name="set">
            <set>
                <value>1</value>
                <value>1</value>
                <value>3</value>
            </set>
        </property>
        <property name="map">
            <map>
                <entry key="country" value="China"/>
                <entry key="province" value="henan"/>
                <entry key="city" value="kaifeng"/>
            </map>
        </property>
        <property name="properties">
            <props>
                <prop key="country">China</prop>
                <prop key="province">hennan</prop>
                <prop key="city">kaifeng</prop>
            </props>
        </property>
    </bean>

13.2 properties文件的加载

<!--    1.开启context命名空间-->
<?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">



<!--    2.使用context空间加载properties文件-->
    <context:property-placeholder location="jdbc.properties" />
<!--    3.使用属性占位符${}读取properties文件中的属性-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>

如果要加载多个配置文件

14 容器

14.1 创建容器

加载配置文件的方法：

Bean加载的三种方式：

14.2 核心容器总结

1 容器相关：

2 Bean相关

3 依赖注入相关

15 注解开发定义Bean

三个衍生注解（本质与Component相同）

16 纯注解开发

17 Bean作用范围和生命周期的管理

singleton为单例，prototype为多例

18 依赖注入

18.1 Bean类型注入

18.2 简单类型注入

18.3 加载文件

19 第三方Bean管理

20.XML配置与注解配置对比

21 Spring整合MyBatis

21.1 导入依赖

    <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.20</version>
            <scope>compile</scope>
        </dependency>

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

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>

    </dependencies>

21.2 MyBatis整合

public class MybatisConfig {

    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.itheima.domain");
        ssfb.setDataSource(dataSource);
        return ssfb;
    }

    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.itheima.dao");
        return msc;
    }
}

22 AOP

22.1 AOP简介

22.2 AOP核心概念

23 AOP入门案例

23.1 导入依赖

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

        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
        </dependency>

23.2 接口和类

public interface BookDao {
    void save();
    void update();
}



@Repository
public class BookDaoImpl implements BookDao {
    public void save(){
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save ...");
    }

    public void update(){
        System.out.println("book dao update ...");
    }
}

23.3 Spring执行程序

public class App {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext acac = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookD = acac.getBean(BookDao.class);
        bookD.update();
    }
}

23.3 Spring配置类

@Configuration
@ComponentScan("com.itheima")
@EnableAspectJAutoProxy   //告诉Spring 是使用注解开发AOP
public class SpringConfig {

}

23.4 AOP实现

@Component  //告诉spring需要被加载
@Aspect     //告诉spring是用来做AOP服务的
public class MyAdvice {
    @Pointcut("execution(void com.itheima.dao.BookDao.update())")    //定义好切入点
    public void pt(){

    }

    @Before("pt()")                   //将切入点和通知绑定
    public void method(){             //定义通知
        System.out.println(System.currentTimeMillis());
    }
}

24 AOP工作流程

25 AOP写入点表达式

26 AOP通知类型

23 测量业务层接口万次执行效率

24 AOP通知获取数据

25 百度网盘密码数据兼容性处理案例：

26 Spring事务简介

27 Spring事务角色

28 spring事务属性

idealer_01
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java开发框架：Spring介绍
啊Q老师
06-09 7236
Spring介绍
Spring+SpringMVC+Mybatis框架整合例子(SSM) 下载
07-21
Spring、SpringMVC和Mybatis是Java开发中最常用的三大开源框架，它们的整合使用，通常被称为SSM框架。这个框架组合提供了完整的后端服务解决方案，包括依赖注入（DI）、面向切面编程（AOP）、模型-视图-控制器（MVC...
【Spring】一个spring简单实例
一定要站在自己热爱的生活里闪闪发光
05-07 7万+
spring的基础知识就不讲了，直接上代码吧！ 为了方便大家创建文件，先把project的结构放在这 1.新建一个projec，本帖设置的名字为“project-hello”. 2. 新建一个package，这里取名为“com.company.project”. 3. 新建一个class，名为“Hello”。代码为： package com.company.project; public class Hello { private String name; pub.
Spring监听器
骑个小蜗牛的博客
12-13 1万+
事件监听概念 应用程序事件允许我们发送和接收特定事件，我们可以根据需要处理这些事件。事件用于在松散耦合的组件之间交换信息。由于发布者和订阅者之间没有直接耦合，因此可以在不影响发布者的情况下修改订阅者，反之亦然。 事件监听三要素 事件源：事件对象的产生者，任何一个事件都有一个来源 ApplicationEvent 事件监听器：事件框架或组件收到一个事件后，需要通知所有相关的事件监听器来进行处理。这些监听器统一存储在事件监听器注册表中。 ApplicationListener（编码式事件监听器） @Event
SpringCache
weixin_47409774的博客
03-17 1万+
Spring 从3.1 开始定义了org.springframework.cache.Cache 和org.springframework.cache.CacheManager 接口来统一不同的缓存技术； 并支持使用JCache（JSR-107）注解简化我们开发； Cache 接口为缓存的组件规范定义，包含缓存的各种操作集合； Cache 接口下Spring 提供了各种xxxCache 的实现； 如RedisCache ， EhCacheCache , ConcurrentMapCache 等； .
Spring启动及Bean实例化过程来看经典扩展接口
张彦峰的博客
04-16 1万+
从Spring启动及Bean实例化过程来看经典扩展接口如下，并给出我们可能的应用分析：BeanPostProcessor+BeanFactoryPostProcessor+ApplicationContextAware++InitializingBean和DisposableBean+BeanDefinitionRegistryPostProcessor+ApplicationListener
【Spring进阶系列丨最终篇】一文详解Spring中的事务控制
陈橘又青的博客
04-22 2万+
- 事务需要放在业务层(service) - Spring的事务是基于AOP的 - Spring的事务控制有两种：编程式事务【了解】和==声明式事务==【重点】 - 声明式事务分为：基于xml配置和基于注解配置
springcloud整合nacos配置中心
Venus's Blog
06-07 7万+
如果大家对相关文章感兴趣，可以关注公众号"架构殿堂"，会持续更新AIGC，java基础面试题, netty, spring boot,spring cloud等系列文章，一系列干货随时送达!
Spring整合RabbitMQ
钟健的博客
03-14 8143
整合用到的maven坐标,主要有：、、和。 1.2 创建RabbitMQ配置文件 这里我们创建的是一个RabbitMQ配置文件，名称为。目的是方便将配置文件中的信息加载到Spring中，就无需在xml文件中修改了。 1.3 创建整合配置文件 RabbitMQ和Spring使用xml文件进行整合，意味着大部分的配置类或模板都在xml文件中，我们默认的文件名为：。xml文件用到的默认约束 （1）加载配置文件，并创建连接工程connectionFactory在这里我们需要注意的是加载配置文件的路径，。 （2）定义
SpringCloud之服务网关Gateway
热门推荐
我的博客
06-30 29万+
前言 SpringCloud 是微服务中的翘楚，最佳的落地方案。 Spring Cloud Gateway 是 Spring Cloud 新推出的网关框架，之前是Netflix Zuul。网关通常在项目中为了简化 前端的调用逻辑，同时也简化内部服务之间互相调用的复杂度；具体作用就是转发服务，接收并转发所有内外 部的客户端调用；其他常见的功能还有权限认证，限流控制等等。 ...
spring框架特点
weixin_57176230的博客
04-25 6087
框架特点 1.方便解耦、简化开发 通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造 成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写 代码，可以更专注于上层的应用。 2.AOP编程支持 通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通 过AOP轻松应付。 3.声明式事务的支持 在Spring中，我们可以...
spring-ai-core 0.8.1
05-21
《Spring AI Core 0.8.1：开启人工智能之旅》 在现代软件开发领域，Spring框架以其强大的功能和灵活性，已经成为Java开发中的首选框架之一。而Spring AI Core则是Spring生态系统中专门为人工智能（AI）和机器学习...
springcloud源码
08-13
Spring Cloud 是一个基于 Spring Boot 实现的微服务框架，它为开发者提供了在分布式系统（如配置管理、服务发现、断路器、智能路由、微代理、控制总线、一次性令牌、全局锁、领导选举、分布式会话、集群状态）操作的...
SpringMVC+Spring+Mybatis集成开发环境
04-28
在IT行业中，SpringMVC、Spring和Mybatis是三大核心框架，它们的集成使用是Java Web开发中的常见实践。这个集成开发环境旨在提供一个高效、灵活的开发平台，以实现业务逻辑与数据访问的分离，提高代码的可维护性和可...
spring jar包
08-05
spring-aop-3.2.2.RELEASE.jar spring-beans-3.2.2.RELEASE.jar spring-context-3.2.2.RELEASE.jar spring-context-support-3.2.2.RELEASE.jar spring-core-3.2.2.RELEASE.jar spring-data-commons-1.5.0.RELEASE....
dubbo和springcloud有什么异同？
最新发布
yszbrzdd的博客
08-15 303
Dubbo主要关注于高效的 RPC 调用和服务治理。提供了一个综合的微服务解决方案，涵盖了从服务注册到配置管理的广泛功能。它们可以根据具体需求和现有技术栈选择使用，也可以结合使用，例如在 Spring Cloud 环境中集成 Dubbo 作为 RPC 框架。
SpringBoot中整合RabbitMQ（测试+部署上线 最完整）
qq_73440769的博客
08-12 1281
包括RabbitMQ在虚拟机本地测试和部署上线通过微信小程序测试，包括Java代码使用示例，也有部署RabbitMQ中的一些困难和解决办法，和最后的解决，配置部署代码一条龙。
SpringBoot
qq_74812898的博客
08-12 591
SpringBoot
Java面试题-JavaEE&框架&中间件（一）
qq_51598807的博客
08-12 892
SELECT 列名 FROM 表1 JOIN 表2 ON 条件 WHERE 条件 GROUP BY 列名 HAVING 条件 ORDER BY 列名 LIMITSpring是一个开源的轻量级控制反转和面向切面编程的容器框架。轻量级是说它开发使用简单，功能强大。控制反转是指将对象的创建，初始化，销毁等工作，以及依赖关系维护交给ioc容器，方便解耦合，降低维护难度。面向切面编程是指将相同的逻辑横向抽取出来，可以对一些通用业务如事务，日志进行集中管理。1）IOC控制反转，把对象的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值