Spring-Aop及jdbc总结

最新推荐文章于 2024-07-09 17:58:26 发布
最新推荐文章于 2024-07-09 17:58:26 发布
阅读量119 收藏
点赞数
文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46060794/article/details/120320090
版权

什么是Aop

AOP（Aspect-OrientedProgramming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

而AOP技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。

使用“横切”技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似。比如权限认证、日志、事务处理。Aop 的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。正如Avanade公司的高级方案构架师Adam Magee所说，AOP的核心思想就是“将应用程序中的商业逻辑同对其提供支持的通用服务进行分离。”

实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。

AOP相关概念


切面（Aspect）：一个关注点的模块化，这个关注点实现可能另外横切多个对象。事务管理是J2EE应用中一个很好的横切关注点例子。方面用Spring的 Advisor或拦截器实现。

连接点（Joinpoint）: 程序执行过程中明确的点，如方法的调用或特定的异常被抛出。

切入点（Pointcut）: 指定一个通知将被引发的一系列连接点的集合。AOP框架必须允许开发者指定切入点：例如，使用正则表达式。 Spring定义了Pointcut接口，用来组合MethodMatcher和ClassFilter，可以通过名字很清楚的理解， MethodMatcher是用来检查目标类的方法是否可以被应用此通知，而ClassFilter是用来检查Pointcut是否应该应用到目标类上

如execution(* com.cqucc.dao.*.*(..))

第一部分*号表示任意返回值

第二部分*号com.DJX.Dao.*表示在com.DJX.Dao包下的任何类

第三部分*号表示任何类下的任何方法

第四部分(..)表示任意参数个数

通知（Advice）: 在特定的连接点，AOP框架执行的动作。各种类型的通知包括“around”、“before”和“throws”通知。通知类型将在下面讨论。许多AOP框架包括Spring都是以拦截器做通知模型，维护一个“围绕”连接点的拦截器链。Spring中定义了四个advice: BeforeAdvice, AfterAdvice, ThrowAdvice和DynamicIntroductionAdvice

目标对象（Target ）: 包含连接点的对象。也被称作被通知或被代理对象。POJO

织入（Weaving）: 组装方面来创建一个被通知对象。这可以在编译时完成（例如使用AspectJ编译器），也可以在运行时完成。Spring和其他纯Java AOP框架一样，在运行时完成织入。

AOP实现方式

1.注解实现

先要对xml的文件进行设置扫描基础包，同时要设置 <aop:aspectj-autoproxy>否则注解不产生效果

       <context:component-scan base-package="com.cqucc" />
       <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

创建类，书写里面的方法并交给Spring管理

import com.cqucc.pojo.User;
import org.springframework.stereotype.Repository;

@Repository
public class UserDao {
    public void save(){
        System.out.println("userdao中实现了1的save");
    }
    public void update(User user){
        System.out.println("dao中实现了1的" + user);
        try {
            System.out.println(1/0);
        }catch (Exception e){
            System.out.println("异常了");
        }
    }
}

创建增强类（增强逻辑）在增强类里面，创建方法，让不同方法代表不同通知类型

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class UserDaoProxy1 {


    @Before(value = "execution(* com.cqucc.dao.UserDao.*(..))")
    public void before(){
        System.out.println("方法执行之前");
    }

    @After(value = "execution(* com.cqucc.dao.UserDao.*(..))")
    public void after(){
        System.out.println("在方法执行之后");
    }

    @AfterReturning(value = "execution(* com.cqucc.dao.UserDao.*(..))")
    public void afterReturning(){
        System.out.println("最终通知");
    }

    @AfterThrowing(value = "execution(* com.cqucc.dao.UserDao.*(..))")
    public void afterthrow(){
        System.out.println("异常通知");
    }

    @Around(value = "execution(* com.cqucc.dao.UserDao.*(..))")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕之前");
        joinPoint.proceed();
        System.out.println("环绕之后");
    }
}

书写测试

    @Test
    public void Test1(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserDao bean = context.getBean(UserDao.class);
        bean.update();
    }

测试结果

2. 书写Pointcut一个方法对上述代码简化 

 

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class UserDaoProxy1 {

    @Pointcut(value = "execution(* com.cqucc.dao.UserDao.*(..))")
    public void point(){

    }

    @Before(value = "point()")
    public void before(){
        System.out.println("方法执行之前");
    }

    @After(value = "point()")
    public void after(){
        System.out.println("在方法执行之后");
    }

    @AfterReturning(value = "point()")
    public void afterReturning(){
        System.out.println("最终通知");
    }

    @AfterThrowing(value = "point()")
    public void afterthrow(){
        System.out.println("异常通知");
    }

    @Around(value = "point()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕之前");
        joinPoint.proceed();
        System.out.println("环绕之后");
    }
}

测试方法同上，结果如下

3.通过配置文件实现 

 配置beans.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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:util="http://www.springframework.org/schema/util"
       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 http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.3.xsd">

       <context:component-scan base-package="com.cqucc" />
       <bean class="com.cqucc.dao.proxy.UserDaoProxy" id="userDaoProxy"></bean>
       <aop:config>
              <aop:pointcut id="point" expression="execution(* com.cqucc.dao.UserDao.*(..))"/>
              <aop:aspect ref="userDaoProxy">
                     <aop:before method="before" pointcut-ref="point"></aop:before>
                     <aop:after method="after" pointcut-ref="point"></aop:after>
                     <aop:after-throwing method="afterthrow" pointcut-ref="point"></aop:after-throwing>
                     <aop:after-returning method="afterReturning" pointcut-ref="point"></aop:after-returning>
                     <aop:around method="around" pointcut-ref="point"></aop:around>
              </aop:aspect>
       </aop:config>
</beans>

配置了xml文件，增强类就不需要注释了

package com.cqucc.dao.proxy;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;


public class UserDaoProxy {


    public void point(){
    }


    public void before(){
        System.out.println("方法执行之前");
    }


    public void after(){
        System.out.println("在方法执行之后");
    }


    public void afterReturning(){
        System.out.println("最终通知");
    }


    public void afterthrow(){
        System.out.println("异常通知");
    }

    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("环绕之前");
        joinPoint.proceed();
        System.out.println("环绕之后");
    }
}

 测试结果

​ Spring整合jdbc

1.配置maven仓库

       <!-- https://mvnrepository.com/artifact/org.springframework/spring-jdbc -->
			<dependency>
			    <groupId>org.springframework</groupId>
			    <artifactId>spring-jdbc</artifactId>
			    <version>5.3.9</version>
			</dependency>
			<!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
			<dependency>
			    <groupId>org.springframework</groupId>
			    <artifactId>spring-tx</artifactId>
			    <version>5.3.8</version>
			</dependency>

2.添加数据库配置文件

 3.使用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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:util="http://www.springframework.org/schema/util"
       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 http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd
		http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-4.3.xsd">

       <context:component-scan base-package="com.cqucc"></context:component-scan>
       <context:property-placeholder location="classpath:db.properties"></context:property-placeholder>
       <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
              <property name="driverClassName" value="${jdbc.driverClassName}"></property>
              <property name="url" value="${jdbc.url}"></property>
              <property name="username" value="${jdbc.username}"></property>
              <property name="password" value="${jdbc.password}"></property>
       </bean>
       <bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
              <property name="dataSource" ref="dataSource"></property>
       </bean>
</beans>

4.创建Cities实体类

package com.cqucc.pojo;

public class Cities {
    private int cid;
    private String cname;
    private int pid;

    public Cities() {
    }


    public Cities(String cname, Integer pid) {
        this.cname = cname;
        this.pid = pid;
    }

    public Cities(Integer cid, String cname, Integer pid) {
        this.cid = cid;
        this.cname = cname;
        this.pid = pid;
    }

    public Integer getCid() {
        return cid;
    }

    public void setCid(Integer cid) {
        this.cid = cid;
    }

    public String getCname() {
        return cname;
    }

    public void setCname(String cname) {
        this.cname = cname;
    }

    public Integer getPid() {
        return pid;
    }

    public void setPid(Integer pid) {
        this.pid = pid;
    }

    @Override
    public String toString() {
        return "Cities{" +
                "cid=" + cid +
                ", cname='" + cname + '\'' +
                ", pid=" + pid +
                '}';
    }
}

对数据库进行基本操作

1. 添加方法

@Repository
public class CitiesDao {

    @Autowired//自动注入
    private JdbcTemplate jdbcTemplate;

    public int insert(Cities cities){
        return jdbcTemplate.update("insert into cities values(null,?,?)"
                 ,cities.getCname(),cities.getPid());
    }
}

测试方法

   @Test
    public void Test2(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans3.xml");
        CitiesDao bean = context.getBean(CitiesDao.class);
        System.out.println(bean.insert(new Cities("重庆",0)));;
    }

插入数据前数据库

添加数据后数据库

 2.删除方法

import com.cqucc.pojo.Cities;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public class CitiesDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;


    public int delete(int cid){
        return jdbcTemplate.update("delete from cities where cid=?",cid);
    }
}

 测试方法

    @Test
    public void Test4(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans3.xml");
        CitiesDao bean = context.getBean(CitiesDao.class);
        bean.delete(23);
    }

删除数据后数据库

 3.批量查询数据

import com.cqucc.pojo.Cities;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public class CitiesDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;


    public List<Cities> selectAll(){
        return jdbcTemplate.query("select * from cities where pidlike ?",new BeanPropertyRowMapper<Cities>(Cities.class)，1);
    }
}

测试方法

    @Test
    public void Test5(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans3.xml");
        CitiesDao bean = context.getBean(CitiesDao.class);
        List<Cities> cities = bean.selectAll();
        System.out.println(cities.size());
        for (Cities c:cities){
            System.out.println(c);
        }
    }

测试结果

4.批量插入数据

import com.cqucc.pojo.Cities;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
public class CitiesDao {

    @Autowired
    private JdbcTemplate jdbcTemplate;


    public int[] inserts(List<Object[]> objects){
        return jdbcTemplate.batchUpdate("insert into cities values(null,?,?)",objects);
    }
}

测试方法

    @Test
    public void Test7(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans3.xml");
        CitiesDao bean = context.getBean(CitiesDao.class);
        List<Object[]> list = new ArrayList<>();
        Object[] c1 = {"重庆",9};
        Object[] c2 = {"重庆1",98};
        Object[] c3 = {"重庆2",98};
        Object[] c4 = {"重庆3",98};
        list.add(c1);
        list.add(c2);
        list.add(c3);
        list.add(c4);
        bean.inserts(list);
    }

测试结果

5.批量删除数据

  public int[] delete(List<Object[]> objects){
        return jdbcTemplate.batchUpdate("delete from cities where pid=?",objects);
    }

 测试方法

    @Test
    public void Test8(){
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("beans3.xml");
        CitiesDao bean = context.getBean(CitiesDao.class);
        List<Object[]> list = new ArrayList<>();
        Object[] c1 = {9};
        Object[] c2 = {98};
        Object[] c3 = {98};
        Object[] c4 = {98};
        list.add(c1);
        list.add(c2);
        list.add(c3);
        list.add(c4);
        bean.delete(list);
    }

测试结果

 

weixin_46060794
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring之AOP及jdbc相关总结
qq_48241564的博客
09-15 231
一、AOP中的几个概念 1、连接点：类里面那些方法可以被增强，这些方法称为连接点（@pointcut就是连接点） 2、切入点：实际被增强的方法，就被称为切入点 如execution(* com.DJX.Dao.*.*(..)) 第一部分*号表示任意返回值 第二部分*号com.DJX.Dao.*表示在com.DJX.Dao包下的任何类 第三部分*号表示任何类下的任何方法 第四部分(..)表示任意参数个数 3、通知：所谓通知指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、
Spring AOP集成jdbc
qq_44333590的博客
03-30 104
spring 事务 事务的概念 事务指数据库中多个操作合并在一起形成的操作序列 事务的隔离级 脏读：允许读取未提交的信息 原因：Read uncommitted 解决方案： （表级读锁） 不可重复读：读取过程中单个数据发生了变化 解决方案： Repeatable read （行级写锁） 幻读：读取过程中数据条目发生了变化 解决方案： Serializable（表级写锁） 事务管理 Spring事务核心对象 spring为业务层提供了整套的事务解决方案 Platfo
Spring AOP、代理、JDBC支持
guanhang89的专栏
09-22 741
代理模式代理（Proxy）是一种设计模式， 提供了对目标对象另外的访问方式；即通过代理访问目标对象。 这样好处： 可以在目标对象实现的基础上，增强额外的功能操作。(扩展目标对象的功能)。 举例：明星（邓紫棋） —经纪人<——-用户 目标 （代理） 代理模式的关键点： 代理对象与目标对象。静态代理静态代理:1） 代理对象，要实现与目标对象一样的接口； 2）
Spring——AOP+Jdbc
qq_40395687的博客
03-13 363
Spring AOP 面向切面编程（动态代理） 动态代理实现： 先定义接口类 package bh.shy.spring.aop; public interface ArithmeticCalculator { public int add(int i,int j); public int sub(int i,int j); public int mul(int i...
Spring学习（三）之AOP及JDBC模板
片羽时光的博客
11-26 262
一.动态代理    1.1 动态代理的原理     代理设计模式的原理：使用一个代理将对象封装起来，然后用代理对象取代原始对象，任何对原始对象的调用都要通过代理，代理对象决定是否以及一何种方式将方法调用转到原始对象上。 1.2动态代理的方式 1.基于接口实现动态代理：JDK动态代理 2.基于继承实现动态代理：Cglib、javassist动态代理 1.JDK的动态代理   (1) Proxy     它是所有动态代理类的父类，专门用来生成代理类或者是代理对象。 //用来生成代理类的Class对象 pub
Spring之注解式AOP和jdbc
终南山_张半仙的博客
06-19 227
先来aop代码： package com.aop; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation....
spring-boot-jdbc：spring-boot-jdbc
02-13
Spring Boot JDBC是Spring框架的一个重要组成部分，它简化了在Java应用程序中使用JDBC（Java Database Connectivity）进行数据库操作的方式。Spring Boot的设计理念是“约定优于配置”，因此它为开发者提供了开箱即...
spring-jdbc jar包.rar
05-03
此外，还可以利用Spring的AOP（面向切面编程）实现全局的事务管理策略。 总的来说，"spring-jdbc jar包"为开发者提供了一个强大且灵活的JDBC抽象层，使得在Java应用中进行数据库操作变得更加简单、高效和可靠。无论...
spring-mvc开发所有jar包【4.3.4】
01-08
10. **spring-jdbc-4.3.4.RELEASE.jar**：JDBC抽象层，提供了一套数据库访问的模板方法和数据源管理，简化了数据库操作，减少了SQL注入的风险。 这些jar包组合在一起，为开发者提供了完整的Spring MVC开发环境，...
spring-aop.rar_java aop_spring aop
09-23
这个压缩包可能包含了一个简单的Spring AOP应用示例，同时也涵盖了Java的一些核心概念，如过滤器、监听器、JDBC等。 【描述】"SPRING AOP自主实现，还包括一些java基础，可以很快自主实现切面编程" 提示我们，此...
Spring aop、jdbc和事务tx练习
11-08
Spring aop、jdbc和事务tx的学习，里面包含了三种的练习，都在不同的包内。
spring-nested-aop.zip_aop_spring aop
09-23
Spring AOP，全称Aspect-Oriented Programming（面向切面编程），是Spring框架的一个重要组成部分。它提供了一种模块化和声明式的方式来处理横切关注点，如事务管理、日志记录、性能监控等，这些关注点通常会分散在...
Spring的AOP和spring对Jdbc的支持(佟刚)
抬头30°的微笑的专栏
08-16 929
1.spring的AOP  AOP(Aspect-Oriented Programming, 面向切面编程):利用的是动态代理技术. 好处: 每个事物逻辑位于一个位置, 代码不分散, 便于维护和升级业务模块更简洁, 只包含核心业务代码. 2.在AOP中经常用的到术语:  切面(Aspect):  横切关注点(跨越应用程序多个模块的功能)被模块化的特殊对象 通知(Advice):
spring AOP开发和JDBC
qq_33265796的博客
04-18 145
实习记录-7AOP简介AOP相关概念AOP术语AOP常用动态代理技术手写JDK动态代理示例手写cglib动态代理示例spring进行AOP开发事项基于XML的AOP开发开发步骤开发示例 AOP简介 AOP相关概念 AOP 的全称是“Aspect Oriented Programming”，即面向切面编程，AOP和面向对象编程（OOP）类似，也是一种编程模 Spring AOP 是基于 AOP 编程模式的一个框架，它的使用有效减少了系统间的重复代码，达到了模块间的松耦合目的。它将业务逻辑的各个部分进行隔离，
Spring与jdbc连接实现增删改查（二）
silence的博客
08-14 1380
接着昨天没有写完的，我们接下来开始实现具体的类 1,建立一个类user,他的属性同我们数据库中的一样（id,name,password，sex）id是主键，他是自定义的自增长 2，建立一个接口类，在这个类中要是实现的方法分别是：保存用户，添加用户，查询用户，删除用户，根据id查找用户 3，实现接口类：实现我们在接口中所定义的方法 4，进行单元测试 还是同昨天一样，最重要的其实就是在配置文
[Spring]Spring AOP学习笔记（3）---Spring JDBC总结
让勤奋成为习惯
09-23 835
最近学习了下Spring JDBC的一些基本用法，故做此总结。 不知道该如何写这篇总结，稍微汇总下本次学习的源代码，未来可能会用上。 Spring JDBC的配置是在XML文件中进行的，配置一定需要连接成功。查询，更新数据都很常规，下面也提供了这些。 另外，NamedParameterJdbcTemplate具名参数是个非常好用的类，当表的列过多的时候，具名参数是个不错的选择。
【烦人的AOP】使用aop对JDBC做拦截
H.CF的博客
05-17 585
<dependency> <groupId>org.aspectj</groupId> <artifactId>aspectjweaver</artifactId> <scope>compile</scope> </dependency> @Aspect public class DaoMonitorAspect { private static final String DB_MONITOR
SpringSecurity认证逻辑源码分析
qq_43676797的博客
07-07 556
类。
SpringBootV12和mybatis全部知识点
最新发布
近日终于有时间好好回顾下一些作品了，有帮助的好好看就行
07-09 921
框架: 快速开发项目的一个架子sshssmspring --> applicationContext.xml配置文件(spring不是业务层,是管理其他框架的)springmvc --> springmvc.xml配置文件 (对应之前servlet)mybatis —> mybatis-config.xml配置文件(对应之前jdbc)—> springboot优化了之前的框架配置,思想是约定大于配置注意：根据网络状况，可能会提示无法连接。如果不能连接，使用http://start.springboot.io
下列哪个不是springboot的starter？ A.spring-boot-starter-aop B.spring-boot-starter-jdbc C.spring-boot-starter-cloud D.spring-boot-starter-test
12-21
1. 关于Spring Boot Starters模块：Spring Boot Starters模块是Spring Boot框架中的一部分，它提供了一组预配置的依赖项，用于简化和加速Spring Boot应用程序的开发。这些Starters模块包含了常见的功能和技术，例如...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值