使用spring中的注解进行开发

       前言：

        在Java中，注解（Annotation）是一种特殊的注释，它提供了一种元数据机制，可以用于描述代码中的信息和指示，并且可以供编译器、开发工具和运行时环境使用。

Spring框架中常用的注解包括：

1. @Controller：用于标记一个类作为SpringMVC Controller对象。被Controller标记的类中的方法就是相应的动作。
2. @Service：用于标记一个类作为SpringMVC Service对象，通常用于业务逻辑层的处理。
3. @Autowired：用于自动装配，可以标注在类成员变量、方法及构造函数上，完成自动装配的工作。
4. @RequestMapping：用于映射HTTP请求到MVC和REST控制器的处理方法上，可以标注在类级别或方法级别上。
5. @Component：表示一个通用注释，用于说明一个类是Spring容器管理的类，但现在不推荐使用。
6. @Scheduled：用于Spring中的定时器任务注解。

除此之外，还有许多其他的注解，比如像bean注入时使用到的@Value，@Autowried和@Qualifier，@Resource等

这里介绍一下这个项目中使用的注解有哪些

1. @Configuration

   作用：用于指定当前类是一个 spring 配置类，当创建容器时会从该类上加载注解。 获取容器时需要使用 AnnotationApplicationContext取加载有@Configuration注解的类.class

   /**
    * spring 的配置类，相当于 bean.xml 文件 
   */ 
   @Configuration 
   public class SpringConfiguration { }

   注意：我们已经把配置文件用类来代替了，但是如何配置创建容器时要扫描的包呢？ 请看下一个注解。

2. @ComponentScan

   作用：用于指定 spring 在初始化容器时要扫描的包。作用和在 spring 的 xml 配置文件中的：

   <context:component-scan base-package="com.fs"/>

   是一样的

   @ComponentScan属性:

   • basePackages/ value:用于指定要扫描的包

3. @bean

   作用：该注解只能写在方法上，表明使用此方法创建一个对象，并且放入 spring 容器。

   属性：name：给当前@Bean 注解方法创建的对象指定一个名称(即 bean 的 id）。

 

1.使用idea创建一个maven项目

目录结构：

2.在pom.xml文件添加如下依赖

<properties>
        <spring.version>5.2.15.RELEASE</spring.version>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <maven.compiler.encoding>UTF-8</maven.compiler.encoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--spring-test-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.10</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <!--log4j-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.36</version>
        </dependency>
    </dependencies>

 3. 在resources中添加一个输出日志的properties文件

log4j.rootCategory=DEBUG, stdout

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %t %c{2}:%L - %m%n

4.创建一个MyConfig类，用来作为配置类

package com.jdfs.config;

import com.jdfs.mapper.UserMapper;
import com.jdfs.mapper.impl.UserMapperImpl;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com.jdfs")
public class MyConfig {

    @Bean("userMapper")
    public UserMapper getUserMapper(){
        return new UserMapperImpl();
    }
}

5. 创建UserMapper类以及接口

package com.jdfs.mapper;

public interface UserMapper {
    void insert();
    void delete();
}
package com.jdfs.mapper.impl;

import com.jdfs.mapper.UserMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
@Slf4j
public class UserMapperImpl implements UserMapper {
    @Override
    public void insert() {
        log.info("保存用户成功...");
    }

    @Override
    public void delete() {
        log.info("删除用户成功...");
    }
}

6.创建UserMapperService接口以及实现类

package com.jdfs.service;
public interface UserMapperService {
    void insert();
    void delete();
}
package com.jdfs.service.impl;

import com.jdfs.mapper.UserMapper;
import com.jdfs.service.UserMapperService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Service("userMapperService")
public class UserMapperServiceImpl implements UserMapperService {
    @Autowired
    @Qualifier("userMapper")
    private UserMapper userMapper;
    @Override
    public void insert() {
        System.out.println("业务层执行insert方法...");
        userMapper.insert();
    }

    @Override
    public void delete() {
        System.out.println("业务层执行delete方法...");
        userMapper.delete();
    }
}

7. 进行测试类的编写

package com.jdfs.service;

import com.jdfs.config.MyConfig;
import com.jdfs.mapper.UserMapper;
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 static org.junit.Assert.*;


@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = MyConfig.class)
public class UserMapperServiceTest {

    @Autowired
    private UserMapperService userMapperService;
    @Test
    public void insert() {
        userMapperService.insert();
    }

    @Test
    public void delete() {
    }
}

8. 测试结果

 总结：

        本次的博客是在学习spring中的注解时，对于注解的一些理解，以及一个简单项目的实现。基于注解开发的好处就是不需要进行很多的配置，这也是为了之后的springboot学习打下基础。但是基于注解的话，就只使用spring不好与其他框架进行整合，在之后的springboot应该能解决。