《spring 实战 第四版》第四章 面向切面的spring

最新推荐文章于 2024-10-10 09:56:47 发布
最新推荐文章于 2024-10-10 09:56:47 发布
阅读量284 收藏 1
点赞数
分类专栏： 读书笔记 文章标签： spring 实战 java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_34565977/article/details/88261896
版权

文章目录

电子书以及项目完整源代码

请戳我

spring 的面向切面

面向切面编程AOP

相关概念

  1. 切面（Aspect）： 一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。由通知（什么时候，做什么）和切入点（在什么地方）组合而成。
  2. 连接点（Joinpoint）： 在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。 在Spring AOP中，一个连接点 总是 代表一个方法的执行。
  3. 通知（Advice）： 在切面的某个特定的连接点（Joinpoint）上执行的动作。
  4. 切入点（Pointcut）： 匹配连接点（Joinpoint）的断言，也就是定义了切面要切入的连接点。通知和切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。 切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。
  5. 引入（Introduction）： （也被称为内部类型声明（inter-type declaration））。声明额外的方法或者某个类型的字段。 Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。 例如，你可以使用一个引入来使bean实现 IsModified 接口，以便简化缓存机制。
  6. 目标对象（Target Object）： 被一个或者多个切面（aspect）所通知（advise）的对象。也有人把它叫做 被通知（advised） 对象。 既然Spring AOP是通过运行时代理实现的，这个对象永远是一个 被代理（proxied） 对象。
  7. AOP代理（AOP Proxy）： AOP框架创建的对象，用来实现切面契约（aspect contract）（包括通知方法执行等功能）。 在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。 注意：Spring 2.0最新引入的基于模式（schema-based）风格和@AspectJ注解风格的切面声明，对于使用这些风格的用户来说，代理的创建是透明的。
  8. 织入（Weaving）： 把切面（aspect）连接到其它的应用程序类型或者对象上，并创建一个被通知（advised）的对象。 这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。 Spring和其他纯Java AOP框架一样，在运行时完成织入。

通知的五种类型

  • 前置通知（Before advice）： 在某连接点（join point）之前执行的通知，但这个通知不能阻止连接点前的执行（除非它抛出一个异常）。
  • 返回后通知（After returning advice）： 在某连接点（join point）正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。
  • 抛出异常后通知（After throwing advice）： 在方法抛出异常退出时执行的通知。
  • 后通知（After (finally) advice）： 当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。
  • 环绕通知（Around Advice）： 包围一个连接点（join point）的通知，如方法调用。这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。

spring AOP

  1. spring AOP是构建在动态代理的基础上，并且该支持仅限于方法拦截。
  2. 如图示，代理类封装包含了目标bean，当外部调用了切入点，即目标对象的某个方法，代理类拦截该调用，执行切面逻辑（即通知），再将其转发给目标对象调用方法。（PS：仅支持方法连接点，不提供字段和构造器的接入点）
    spring AOP 原理

通过切点选择连接点

spring支持的切点指示器

切点指示器

编写切点

  • 当perform（）方法执行时触发通知

    在这里插入图片描述
execution(* concert.Performance.perform())
  • 加上限制条件 within() 和 与或判断（&& 、 || ！以及xml使用的 and、or、not）

    在这里插入图片描述

切点中选择bean

  • 使用bean()方法，通过bean ID 或者bean 名称来匹配bean
execution(* concert.Performance.perform())
    and bean('woodstock')
匹配ID为woodstock的bean

使用注解

目标对象

接口 Performance.java

public interface Performance {
    public void perform();
}

目标类 Concert.java

@Component
public class Concert implements Performance {

    public void perform() {
        System.out.println("Performing...");
    }

}

定义切面

Audience.java

@Component
@Aspect
public class Audience {

    @Before("execution(* com.zexing.aspectj.Performance.perform(..))")//表演之前手机静音
    public void silenceCellPhones(){
        System.out.println("silencing cell phones");
    }

    @Before("execution(* com.zexing.aspectj.Performance.perform(..))")//表演之前坐好位置
    public void takeSeats(){
        System.out.println("Taking seats");
    }

    @AfterReturning("execution(* com.zexing.aspectj.Performance.perform(..))")//表演成功后鼓掌呐喊
    public void applause(){
        System.out.println("CLAP CLAP CLAP！");
    }

    @AfterThrowing("execution(* com.zexing.aspectj.Performance.perform(..))")//表演失败后要求退款
    public void demandRefun(){
        System.out.println("Demanding a refun");
    }
    
}
  • @Aspect

将POJO类定义为一个切面（如Audience类）

  • @Before

目标方法之前执行注解的通知方法（如在perform()之前执行silenCellPhones()和takeSeats()）

  • @After

目标方法返回或抛出异常后执行通知方法

  • @AfterReturning

目标方法返回后执行

  • @AfterThrowing

目标方法抛出异常后执行

  • @Around

通知方法将目标方法封装

可以使用@Pointcut 进行重构，抽出重复的切点表达式

    @Pointcut("execution(* com.zexing.aspectj.Performance.perform(..))")
    public void performance(){
    
    }

    @Before("performance()")//表演之前手机静音
    public void silenceCellPhones(){
        System.out.println("silencing cell phones");
    }

配置类或者xml文件启用自动代理

  • 注解方式

启动后这里spring容器才会将audience bean 创建为切面

@Configuration
@EnableAspectJAutoProxy     //启用自动代理
@ComponentScan
public class ConcertConfig {
}
  • xml方式
    <context:component-scan base-package="com.zexing.aspectj" />

    <aop:aspectj-autoproxy />

    <bean id="audience" class="com.zexing.aspectj.Audience" />

AspecJ自动代理都会使用@Aspect注解的bean创建一个代理,而这个代理会围绕着所有该切面的切点所匹配的bean。

测试

测试类 ConcertConfigTest.java

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = ConcertConfig.class)
//@ContextConfiguration(locations = "classpath*:app.xml")
public class ConcertConfigTest {

    @Autowired
    private Performance concert;

    @Test
    public void concertStart(){

        assertNotNull(concert);
        concert.perform();
    }
}

结果

silencing cell phones
Taking seats
Performing...
CLAP CLAP CLAP！

环绕通知

Audience.java

@Aspect
public class Audience {

    @Pointcut("execution(* com.zexing.aspectj.Performance.perform(..))")
    public void performance(){
    }
    
    @Around("performance()")
    public void watchPerformance(ProceedingJoinPoint jp) {
        try {
            System.out.println("手机静音");
            System.out.println("得到座位");
            jp.proceed();
            System.out.println("鼓掌!!!");
        } catch (Throwable e) {
            System.out.println("这演的啥啊！退票");
        }
    }
    
}

这里的 @Around注解就声明了watchPerformance()方法成为了一个环绕通知切点。他的运行结果与上例使用@Before,@After等等的效果相同。可以发现watchPerformance()方法中给出了一个PreceedingJoinPoint类型的参数，这个是必须的，因为你需要告诉该切点中的任务相对与你的工作所处的位置。使用ProceedingJoinPoint’s proceed()方法将你的任务放在你想要的位置

测试结果

手机静音
得到座位
Performing...
鼓掌!!!

处理通知中的参数

通知里面获取被通知方法的参数并进行处理

在CDPlayer播放中，记录磁道的播放次数与播放本身是不同的关注点，因此不应该属于playTrack()方法，故统计次数是切面的任务，切面获取磁道名称并记录其出现的次数。

目标类 CDPlayer.java

@Component
public class CDPlayer {
    /**
     *
     * Created by Joson on 2/25/2019.
     */
    @Autowired
    private CompactDisc cd;

    public void playTrack() {
        System.out.println(cd);
    }

    public void play(int index) {
        System.out.println(cd.getTracks().get(index-1) + " is playing....");
    }
}

CompactDisc.java

@Component
public class CompactDisc {
    /**
     *
     * Created by Joson on 2/25/2019.
     */
    private String title;
    private List<String> tracks;

    public CompactDisc(){} // 如果自定义了构造方法，必须显式地定义默认构造方法，否则 Spring 无法实现自动注入

    public CompactDisc(String title, List<String> tracks) {
        this.title = title;
        this.tracks = tracks;
    }

    public List<String> getTracks() {
        return tracks;
    }
}

切面类 TrackCounter.java

@Aspect
@Component
public class TrackCounter {
    /**
     *
     * Created by Joson on 2/25/2019.
     */
    private Map<Integer, Integer> map = new HashMap<Integer, Integer>();

    // execution(...play(int))的 int 是被通知的方法的获得的参数的类型
    // 通过 && args(trackNumber) 表示被通知方法的实参也将传递给通知方法
    @Pointcut("execution(* com.zexing.aspectj.trackPlayCount.CDPlayer.play(int)) && args(trackNumber)")
    public void pointcut(int trackNumber) { // 形参名必须和 args()一致
    }

    // @Around("trackPlayed(trackNumber)")中的 "trackNumber"
    // 不必与 args() 相同 ，可以另外命名的，但必须保证本通知内一致即可。
    @Around("trackPlayed(trackNumber)")
    public void countTrack(ProceedingJoinPoint pjp, int trackNumber) {
        try {
            pjp.proceed(); //调用被通知方法
            // 每次调用被通知方法成功之后，音轨的播放次数+1
            int currentCount = getTrackCurrentCount(trackNumber);
            map.put(trackNumber, ++currentCount);
        } catch (Throwable e) {
            // 调用出现异常后的代码
            System.out.println("CDPlayer 播放异常！");
        }
    }

    public int getTrackCurrentCount(int trackNumber) {
        return map.containsKey(trackNumber) ? map.get(trackNumber) : 0;
    }
}

这里我们用 @PointCut 注解了一个带有int参数的方法 trackPlayed() ，将其定义为一个切点。在 @PointCut 中我们去匹配 CompactDisc 类中的 play() 方法，并且定制了其参数类型为int，这里当这样限制了被切入方法的类型，就必须同时使用 args() 标识符来指明变量的名字。

配置类 CompactDiscConfig.java

@Configuration
@EnableAspectJAutoProxy     //启用自动代理
@ComponentScan
public class CompactDiscConfig {
    /**
     *
     * Created by Joson on 2/25/2019.
     */
    /*
    由于CompactDisc类中有两个构造方法，Spring在匹配 bean 时出现冲突，所以必须显式指定一个bean。
    否则将出现异常，大概就是说，我只一个 bean 就够了，但给我两个，叫我怎么选啊：
    No qualifying bean of type 'com.san.spring.aop.CD' available:
    expected single matching bean but found 2: CD,setCD
    */
    @Bean
    @Primary //首选bean
    public CompactDisc compactDisc(){
        String title = "唐朝";
        List<String> tracks = new ArrayList<String>();
        tracks.add("梦回唐朝");
        tracks.add("太阳");
        tracks.add("九拍");
        tracks.add("天堂");
        tracks.add("选择");
        tracks.add("飞翔鸟");
        tracks.add("世纪末之梦");
        tracks.add("月梦");
        tracks.add("不要逃避");
        tracks.add("传说");

        return new CompactDisc(title, tracks);
    }
}

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = CompactDiscConfig.class)
public class CompactDiscConfigTest {

    @Autowired
    private CDPlayer player;

    @Autowired
    private TrackCounter trackCounter;

    @Test
    public void testTrackCounter() {

        // 执行 play()一次，该音轨的播放次数加1
        player.play(1);
        player.play(1);
        player.play(2);
        player.play(3);
        player.play(5);

        // 与期待的次数一致，则测试通过
        assertEquals(2, trackCounter.getTrackCurrentCount(1));
        assertEquals(1, trackCounter.getTrackCurrentCount(2));
        assertEquals(1, trackCounter.getTrackCurrentCount(3));
        assertEquals(0, trackCounter.getTrackCurrentCount(4));
        assertEquals(1, trackCounter.getTrackCurrentCount(5));
    }

}

通过注解引入新功能

上面我们都是在方法上新增功能方法，同样的，切面可以实现类级别上新增方法。
如图示，切面引入新方法流程

在这里插入图片描述

当引入接口的方法被调用时，代理会把此调用委 托给实现了新接口的某个其他对象。实际上，一个bean的实现被拆分到了多个类中。

场景描述：

在一场音乐会中，添加潮剧表演的环节，但在原来的音乐会表演类（Concert.java）中没有这个方法，所以需要为这个表演类再新加一个方法。

  1. 创建表演者接口
public interface Performer {
    public void performAdded();
}
  1. 指派一个表演者去表演潮剧
@Component
public class OnePerformer implements Performer {

    /**
     *
     * Created by Joson on 2/26/2019.
     */
    public void performAdded() {
        System.out.println("潮剧表演...");
    }
}
  1. 通过主持人（切面类）的介绍
@Component
@Aspect
public class PerformIntroducer {
    /**
     *
     * Created by Joson on 2/26/2019.
     */
    //通过 PerformIntroducer 的介绍，潮剧表演者进入音乐会进行加场表演
    @DeclareParents(value = "com.zexing.aspectj.concert.Performance+",defaultImpl = OnePerformer.class )
    public static Performer performer;
}

通过@DeclareParents注解，将Performer接口引入 到Performance bean中。

@DeclareParents注解由三部分组成：

  • value属性指定了哪种类型的bean要引入该接口。在本例中，也 就是所有实现Performance的类型。（标记符后面的加号表示 是Performance的所有子类型，而不是Performance本 身。）
  • defaultImpl属性指定了为引入功能提供实现的类。在这里， 我们指定的是OnePerformer提供实现。
  • @DeclareParents注解所标注的静态属性指明了要引入的接 口。在这里，我们所引入的是Performer接口。
  1. 开始音乐会
    @Test
    public void addPerform(){
        assertNotNull(concert);
        concert.perform();
        System.out.println("--下面进行临时加场表演--");
        Performer p = (Performer) concert;
        p.performAdded();
    }
  1. 音乐会
手机静音
得到座位
silencing cell phones
Taking seats
Performing...
鼓掌!!!
CLAP CLAP CLAP！
--下面进行临时加场表演--
潮剧表演...

在Spring中，注解和自动代理提供了一种便利的方式来创建切面，它非常简单，并且只设计最少的Spring配置，但是，面向注解的切面有一个明显的不足点：你必须能够为通知类添加注解，为了做到这一点，必须要有源码。

使用XML

  • xml中切面的声明标签
  1. aop:advisor :定义AOP通知器
  2. aop:after :定义AOP后置通知
  3. aop:after-returning :定义AOP返回通知
  4. aop:after-throwing :定义AOP异常通知
  5. aop:around :定义AOP环绕通知
  6. aop:aspect :定义一个切面
  7. aop:aspectj-autoproxy :启用@AspectJ注解
  8. aop:before :定义一个AOP前置通知
  9. aop:poiontcut :定义一个切点
  • 声明前后置通知
<!--声明切面 -->
    <aop:config>
        <aop:aspect ref="audience">       <!--引用audience Bean-->

            <aop:before pointcut="execution(* com.zexing.aspectj.concert.Performance.perform(..))" method="silenceCellPhones"/>

            <aop:before pointcut="execution(* com.zexing.aspectj.concert.Performance.perform(..))" method="takeSeats"/>

            <aop:after-returning pointcut="execution(* com.zexing.aspectj.concert.Performance.perform(..))" method="applause"/>

            <aop:after-throwing pointcut="execution(* com.zexing.aspectj.concert.Performance.perform(..))" method="demandRefun"/>

        </aop:aspect>
    </aop:config>
  • 声明切点
<!--声明切点 -->
    <aop:config>
        <aop:aspect ref="audience">
            <aop:pointcut id="performance" expression="execution(* com.zexing.aspectj.concert.Performance.perform(..))" />

            <aop:before pointcut-ref="performance" method="silenceCellPhones"/>

            <aop:before pointcut-ref="performance" method="takeSeats"/>

            <aop:after-returning pointcut-ref="performance" method="applause"/>

            <aop:after-throwing pointcut-ref="performance" method="demandRefun"/>

        </aop:aspect>
    </aop:config>
  • 声明环绕通知
<!-- 声明环绕通知-->
    <aop:config>
        <aop:aspect ref="audience">       <!--引用audience Bean-->
            <aop:pointcut id="performance" expression="execution(* com.zexing.aspectj.concert.Performance.perform(..))"  />

            <aop:around pointcut-ref="performance" method="watchPerformance"/>

        </aop:aspect>
    </aop:config>
  • 为通知传递参数
<!-- 为通知传递参数-->
    <bean id="player" class="com.zexing.aspectj.trackPlayCount.CDPlayer" />
    <!-- 构造器注入属性-->
    <bean id="cd" class="com.zexing.aspectj.trackPlayCount.CompactDisc" >
        <constructor-arg name="title" value="唐朝" />
        <constructor-arg name="tracks">
            <list>
                <value>梦回唐朝</value>
                <value>太阳</value>
                <value>九拍</value>
                ...
            </list>
        </constructor-arg>

    </bean>
    <bean id="trackCounter" class="com.zexing.aspectj.trackPlayCount.TrackCounter" />

    <aop:config>
        <aop:aspect ref="trackCounter">
            <aop:pointcut id="trackPlayed" expression="execution(* com.zexing.aspectj.trackPlayCount.CDPlayer.play(int)) and args(trackNumber)" />
            <!-- 这里args()的trackNumber 必须与类中countTrack()方法的参数名保持一致-->
            <aop:around pointcut-ref="trackPlayed" method="countTrack" />
        </aop:aspect>
    </aop:config>
  • 为通知新增方法
<!-- 为bean 新增方法-->
    <bean id="onePerformer" class="com.zexing.aspectj.concert2.OnePerformer" />

    <aop:config>
        <aop:aspect ref="audience">       <!--引用audience Bean-->
            <aop:declare-parents types-matching="com.zexing.aspectj.concert.Performance"
                                 implement-interface="com.zexing.aspectj.concert2.Performer"
                                 delegate-ref="onePerformer" />
        </aop:aspect>
    </aop:config>
zhangzexing789
关注
专栏目录
《Spring实战》学习笔记-第四章：面向切面的Spring
生命在于折腾
01-14 2090
分布于应用中多处的功能称为横切关注点，通过这些横切关注点在概念上是与应用的业务逻辑相分离的，但其代码往往直接嵌入在应用的业务逻辑之中。将这些横切关注点与业务逻辑相分离正是面向切面编程（AOP）所要解决的。
spring实战笔记_第4章
kudosCoding的博客
04-07 780
一、面向切面编程（AOP）1.1问题：图展现了一个被划分为模块的典型应用。每个模块的核心功能都是为特定业务领域提供服务，但是这些模块都需要类似的辅助功能，例如安全和事务管理。如果要重用通用功能的话，最常见的面向对象技术是继承（inheritance）或委托（delegation）。但是，如果在整个应用中都使用相同的基类，继承往往会导致一个脆弱的对象体系；而使用委托可能需要对委托对象进行复杂的调用。...
spring4实战第四版 (maven 版本) 之第四章 面向切面aop chapter4
12-11
spring4实战源代码之第四章: 面向切面aop ; maven 版本 网上几乎没有关于aop的源码，将自己的练习 打包给大家，仅供参考
读《Spring 实战（第四版）》第四章 Spring面向切面
sakuragio的博客
07-29 113
Spring AOP是基于动态代理的，所以只支持方法连接点 Spring仅支持Aspectj切点指示器的一个子集 1 p107 ↩︎
《Spring实战》第四版 第四章4.3.3 处理通知中的参数 节 ——源码实现及笔记
skyleadGX的博客
03-21 416
本博客谨记载个人在Spring学习中遇到的问题和体会，如有错误，恳请大家指教& 一 介绍 本博客内容为本人学习《Spring实战》(第四版) 4.3.3节，做的笔记及源码实现。因为第二章装配Bean没有深入掌握，加上书籍附带源码包中沒有第四章相关代码，所以此处我遭遇一些障碍，通过重新学习第二章，最后实现了此节阐述的内容。 二 笔记 自动装配（autowiring） ： Spr...
Spring实战（第4版）第4章 面向切面的Spring
天空鸟的博客
08-26 376
第4章　面向切面的Spring 本章内容： 面向切面编程的基本原理 通过POJO创建切面 使用@AspectJ注解 为AspectJ切面注入依赖 在编写本章时，得克萨斯州（我所居住的地方）正值盛夏，这几天正在经历创历史记录的高温天气。这里真的非常热，在这种天气下，空调当然是必不可少的。但是空调的缺点是它会耗电，而电需要钱。为了享受凉爽和舒适，我们没有什么办法可以避免这种开销。这是因为每家每户都有一个电表来记录用电量，每个月都会有人来查电表，这样电力公司就知道应该收取多少费用了。 现在想象一下，如果没有电
Spring实战（第四版）
CYH1370的博客
02-15 674
Spring的核心类库是 DefaultListableBeanFactory 一个 Spring 组件可以是任何形式的 POJO JavaBean的同义词（本书中）是POJO Spring 最根本的使命上：简化 Java 开发 重量级开发：EJB 轻量级开发：Spring 为了降低 Java 开发的复杂性，Spring 采取了以下 4 种关键策略： 基于 POJO 的轻量级和最小侵入性编程； 通过依赖注入和面向接口实现松耦合； 基于切面和惯例进行声明式编程；
SpringiA4_SourceCode:Spring实战第四版源码，学习用。
01-19
《Spring实战第四版》是Java开发领域中一本深入讲解Spring框架的经典著作，源代码的提供为读者提供了亲自动手实践的机会，有助于加深理解和应用。在这个压缩包中，包含的文件名为"spring4源码_Code4"，我们可以推测...
Spring 实战 第四版 pdf （高清）
11-15
《Spring实战 第四版》是一本深度探讨Spring框架的权威指南，专为希望掌握Spring进行Web开发的读者而设计。本书全面覆盖了Spring的核心概念和技术，包括但不限于IoC（Inversion of Control，控制反转）、AOP（Aspect...
Spring
zyy5411的专栏
05-08 701
SpringSpring 是啥？Spring是个大家都听过的东西，或者在许多web项目中都有看到过的东西，然而，要清楚地说出Spring是个啥？Spring存在的意义？可能大多数人只能够照本宣科的说出一些。我希望能够更简单的去解释Spring。其实，在我看来，Spring的众多特性，想要达到的目的是：让开发者更好的基于POJO编程。将重复性、依赖性的代码从类中剥离出来。 什么是上面所说的POJO
Spring Boot实战之Filter实现使用JWT进行接口认证
热门推荐
sun_t89的专栏
07-16 7万+
Spring Boot实战之Filter实现使用JWT进行接口认证 jwt(json web token) 用户发送按照约定，向服务端发送 Header、Payload 和 Signature，并包含认证信息（密码），验证通过后服务端返回一个token,之后用户使用该token作为登录凭证，适合于移动端和api jwt使用流程 本文示例接上面几篇文章中的代码
Spring实战（4）-AOP
馒头Lynn的博客
10-15 394
AOP概述 AOP是一种编程思想。称为：面向切面编程。是对OOP的一种补充。 举个例子解释这种编程思想： 一个饭店的服务员，在接待每个新客人的时候，我们假如它都进行三个操作：接客--&gt;服务--&gt;送客。那么在oop编程中，如果接待了一百个客人，那么就需要写一百次这三个操作。 而我们发现，其中接客和送客这两个环节，对不同的客户是相同的操作，不同的客户只有服务的内容不同。那么我们...
C++学习笔记----8、掌握类与对象（四）---- 不同类型的数据成员（1）
weixin_71738303的博客
10-05 948
c++对于数据成员给了你许多选项。除了在类中声明简单的数据成员，可以生成静态数据成员供所有类的对象共享，const成员，引用成员，reference-to-const成员，等等。本节我们解释一下这些不同类型的数据成员的细节。
【JAVA开源】基于Vue和SpringBoot的高校学科竞赛平台
最新发布
杨荧的CSDN博客
10-10 1012
教师功能有个人中心，题目类型管理，竞赛题库管理，竞赛类型管理，竞赛信息管理，报名信息管理，竞赛评分管理，参赛名单管理，晋级名单管理，获奖名单管理，竞赛总结管理，报销清单管理，成绩申诉管理，参赛信息管理，参赛信息管理，往年成绩管理，获奖情况管理。
C语言 | 第十章 | 函数 作用域
ZJC744575的博客
10-05 1281
为完成某一功能的程序指令(语句)的集合,称为函数。在C语言中,函数分为:自定义函数、系统函数(查看C语言函数手册)函数还有其它叫法，比如方法等，在本视频课程中，我们统一称为 函数。返回类型 函数名（形参列表）{执行语句...;// 函数体return 返回值;// 可选形参列表：表示函数的输入函数中的语句：表示为了实现某一功能代码块函数可以有返回值,也可以没有, 如果没有返回值，返回类型 声明为 void。
JDK1.0主要特性
FoolRabbit的专栏
10-06 378
JDK1.0主要特性。
字符函数和字符串函数和内存函数
Java_fenxiang的博客
10-05 713
strtok函数原型与功能概述在 C 语言中，strtok函数的原型为char *strtok(char *str, const char *delim)。它的主要功能是将字符串str按照delim中指定的分隔符进行分割，返回被分割出来的子字符串。工作原理首次调用：当第一次调用strtok时，需要将待分割的字符串str作为...
基于JavaWeb开发的java springmvc+mybatis酒水商城管理系统设计和实现
央顺科技官方博客
10-08 1516
基于JavaWeb开发的java springmvc+mybatis酒水商城管理系统设计和实现
Spring实战第四版：核心、Web、后台与集成全面解析
"Spring in Action 第四版" 是一本由 Craig Walls 撰写的关于 Spring 框架的权威指南，全面覆盖了 Spring 4 的最新特性。这本书分为四个部分，详细讲解了 Spring 在核心、Web 开发、后端以及集成方面的应用。 第一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值