Spring boot 注解Annotation大全【持续更新】_springboot的指定配置文件的注解

        为了方便我们在日常开发注解的使用，本文将开发所需要的注解统一并进行归类起来,并结合用例进行解析，这样收藏起来以便日后使用。最主要本文将持续更新日常使用的注解，也可以评论中告知其他注解。

1依赖注入

---

1.1组件注解 @component

        @component，而其余 @Controller、@Service、@Repository都组合了@component注解，主要为便于使用者Class组件进行归类。

        默认加载IOC容器中的组件，容器启动会调用无参构造器创建对象，再进行初始化赋值等操作

1.2依赖注入注解

        @Autowired和@Inject、@Resource，可以与@Qualifier或者@Name配合使用，防止多实例注入时出错，以及值注入@Value。

1.3 作用域和生命过程

        @Scope，具有4个作用域可看Scope作用域以及涉及的问题章节，以及生命周期过程处理@PostConstruct、@PreDestroy 。

1.4 章节用例（结合1.1、1.2、1.3小节）

@Service //组件注入，注明为service组件
@Scope("prototype")//声明Scope为Prototype
public class UseFunctionService {
    
    @Autowired //默认按type注入
    @Qualifier("functionService") //精确注入
    FunctionService functionService;

    @Resource(name="baseDao")//默认按name注入，可以通过name和type属性进行选择性注入
    private BaseDao baseDao;

    @Inject
    @Qualifier("userServiceImpl") //精确注入  
    public IUserService userService;  
    
    @PostConstruct//执行完构造函数后执行
    public postConstruct(){
        System.out.println("postConstruct");
    }

    @PreDestroy//在销毁Bean前执行
    public perDestroy(){
         System.out.println("perDestroy");
    }

    @Autowired   
    public void setUserDao(@Qualifier("userDao") UserDao userDao) {   
     this.userDao = userDao;   
    }  

    public String SayHello(String word){
        return functionService.sayHello(word);
    }
}

2. 配置注解

---

2.1 @Configuration配置注解

        @Configuration可替换xml配置文件进行配置。被注解的类内部包含有一个或多个被@Bean注解的方法,这些方法将会被AnnotationConfigApplicationContext或AnnotationConfigWebApplicationContext类进行扫描，并用于构建bean定义，初始化Spring容器。可与@PropertySource一起使用。 @Configuration作为元注解延伸了@SpringBootConfiguration

2.2扫描注解

@ComponentScan注解,被@Configuration注解标注的类上面,涉及了@filter过滤器注解

2.3 资源、值等注入注解

可以将配置文件、配置文件中的属性、以及系统属性等注入所需的字段中，或者bean中

2.4 条件注解 @Conditional

@Conditional根据满足某一特定条件创建特定的Bean，基于@Conditional元注解可延伸很多条件注解。

2.5 章节用例(2.1、2.2、2.3、2.4小节)

@Configuration
//@SpringBootConfiguration
@ComponentScan(value="com.cn",ComponentDefaultFilters=true,
  includeFilters={
    @Filter(type=FilterType.ANNOTATION,classes={Controller.class}),
    @Filter(type=FilterType.CUSTOM,classes={MyTypeFilter.class})
})
@ImportResource("classpath:condition.xml")//导入xml配置
@Import(ConditionConfig.class)//导入ConditionConfig Class，并会实例化到容器中以及ConditionConfig中的配置也一起注入
public class Config {
     @Value("I Love You!") //注入普通字符
    private String normal;
    @Value("#{systemProperties['os.name']}") //注入操作系统属性
    private String osName;
    @Value("#{ T(java.lang.Math).random() * 100.0 }") //注入表达式运算结果
    private double randomNumber;
    @Value("#{demoService.another}") //注入其他Bean的属性
    private String fromAnother;
    @Value("classpath:org/light4j/sping4/usually/el/test.txt") //注入文件内容
    private Resource testFile;
    @Value("http://www.baidu.com") //注入网址内容
    private Resource testUrl;
    @Value("${book.name}") //注入属性文件
    private String bookName;

    @Bean//加载bean
    @Conditional(WindowsCondition.class) // 通过@Conditional注解，符合Windows条件则true
    @ConditionalOnResource(resources="classpath:windows.ini")//在类路径下是否存在windows.ini文件，存在为true,最后进行注解与操作，为true实例化Bean
    public ListService windowsListService(){
        return new WindowsListService();
    }

    @Bean
    @ConditionalOnClass(LinuxCondition.class) // 通过@ConditionalOnClass注解，符合Linux条件则true
    @ConditionalOnProperty(name = "synchronize", havingValue = "true"))//如果synchronize在配置文件中并且值为true
    public ListService linuxListService(){
        return new LinuxListService();
    }
    //加载配置文件中前缀为spring.datasource的属性
     @ConfigurationProperties(prefix = "spring.datasource")
      public DataSource jwcDataSource() {
         return DataSourceBuilder.create().build();
    }

    @Bean
    @ConditionalOnMissingClass({LinuxCondition.class,WindowsCondition.class})//当容器中缺失这两个Class时为true
    @Profile("dev")//在dev环境下为true  最后结果为注解和之与，true实例化该Bean
    public ListService macListService(){
        return new MacListService();
    }
}

3. 验证注解

---

验证注解在javax.validation包下：

4.AOP

---

4.1 AspectJ的注解式切面编程：

AspectJ的注解式在org.aspectj包下

4.2 AspectJ指示器

execution指示器是我们在编写切点定义时最主要使用的指示器：

4.3 用例：编写切面

@Aspect //声明该类是一个切面
@Component 
public class LogAspect {
    private final String POINT_CUT ="execution(* org.sping4.ccww.aop.DemoMethodService.*(..))";
    
     @Pointcut("@annotation(org.ccww.sping4.base.aop.Action)") //声明切面
     public void annotationPointCut(){};

     @After("annotationPointCut()") //声明一个建言，并使用@Pointcut定义的切点
    public void after(JoinPoint joinPoint) {
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        Action action = method.getAnnotation(Action.class); 
        System.out.println("注解式拦截 " + action.name()); //⑤
    }

     @Before("execution(* org.sping4.ccww.aop.DemoMethodService.*(..))")//声明一个建言，此建言直接使用拦截规则作为参数
      public void before(JoinPoint joinPoint){
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        Method method = signature.getMethod();
        System.out.println("方法规则式拦截,"+method.getName());
    }
    
    /**
    * 后置返回
    * 如果第一个参数为JoinPoint，则第二个参数为返回值的信息
    * 如果第一个参数不为JoinPoint，则第一个参数为returning中对应的参数
    * returning：限定了只有目标方法返回值与通知方法参数类型匹配时才能执行后置返回通知，否则不执行，
    * 参数为Object类型将匹配任何目标返回值
    */
    @AfterReturning(value = POINT_CUT,returning = "result")
    public void doAfterReturningAdvice1(JoinPoint joinPoint,Object result){
         System.out.println("第一个后置返回通知的返回值："+result);
    }
}

5. Spring MVC

---

用例：

@Controller //声明此类是一个控制器
@RequestMapping("/ccww") //映射此类的访问路径是/ccww
//@RestController // 使用@RestController，声明是控制器，并且返回数据时不需要@ResponseBody
//@RequestMapping("/ccww")
public class DemoAnnoController {
    //此方法未标注路径，因此使用类级别的路径/anno;produces可定制返回的response的媒体类型和字符集，或返回值是json对象，则设置porduces="application/json;charset=UTF-8"
    @RequestMapping(produces = "text/plain;charset=UTF-8")  
    public @ResponseBody String index(HttpServletRequest request) { //可接受HttpServletRequest作为参数，当然也可以接受HttpServletResponse作为参数。此处的@ResponseBody用在返回值前
        return "url:" + request.getRequestURL() + " can access";
    }
    @RequestMapping(value = "/demoPathVar/{str}", produces = "text/plain;charset=UTF-8")// 
    public @ResponseBody String demoPathVar(@PathVariable String str, //接受路径参数，并在方法参数前结合@PathVariable使用，访问路径为/ccww/demoPathVar/xxx
            HttpServletRequest request) {
        return "url:" + request.getRequestURL() + " can access,str: " + str;
    }
    //常规的request参数获取，访问路径为/ccww/requestParam?id=1
    @RequestMapping(value = "/requestParam", produces = "text/plain;charset=UTF-8") 
    public @ResponseBody String passRequestParam(Long id,
            HttpServletRequest request) {
        return "url:" + request.getRequestURL() + " can access,id: " + id;
    }
    @RequestMapping(value = "/obj", produces = "application/json;charset=UTF-8")
    @ResponseBody // 可注解在方法上
    public String passObj(DemoObj obj, HttpServletRequest request) {
         return "url:" + request.getRequestURL() 
                    + " can access, obj id: " + obj.getId()+" obj name:" + obj.getName();
    }
    //映射不同的路径到相同的方法，访问路径为/anno/name1或/anno/name2
    @RequestMapping(value = { "/name1", "/name2" }, produces = "text/plain;charset=UTF-8")
    public @ResponseBody String remove(HttpServletRequest request) {
        return "url:" + request.getRequestURL() + " can access";
    }
    
     @RequestMapping(value = "/helloWorld") 
     //以“user”为名称添加到模型对象中供视图页面展示使用
    public String helloWorld(@ModelAttribute User user) { 
     return "helloWorld"; 
    } 
}

6.Spring security

---

Spring security用户访问认证和授权,两个关键注解：

用@EnableGlobaleMethodSecurity的参数想要开启注解：

• @EnableGlobalMethodSecurity(securedEnabled=true)：开启@Secured注解过滤权限
• @EnableGolablMethodSecurity(jsr250Enabled=true)：开启@RolesAllowed注解过滤权限
• @EnableGlobalMethodSecurity(prePostEnable=true)：使用Spring_EL表达式控制更细粒度的访问控制

具体开启注解解析如下：

用例：

两个关键注解@EnableWebSecurityConfig、@EnableGlobaleMethodSecurity：

@Configuration
@EnableWebSecurity//开启webSecurityConfig
@EnableGlobalMethodSecurity(prePostEnabled = true.securedEnabled = true)//可开启多个注解
public class WebSecurityConfig extends WebSecurityConfigurerAdapter{
    .....
}

其他注解：

@Secured("IS_AUTHENTICATED_ANONYMOUSLY")//@Secured注解，匿名访问
public Account readAccount(Long id){
    ...
}
 
@Secured("ROLE_TELLER")//@Secured注解具有TELLER访问
public Account readAccount(Long id){
    ...
}
@PreAuthorize("#userId==authentication.principal.userId or hasAuthority('ADMIN')")
//利用Spring Security的@P标注参数，或者Spring Data的@Param标注参数来接收@PreAuthorize的返回值
public void changPassword(@P("userId")long userId){
  ...
 }
@PreAuthorize("hasAuthority('ADMIN')")//PreAuthorize是否具有admin角色
public void changePassword(long userId){
...
}

#######################################

例子2：如何使用
①. 注解如何使用？
/**
 * 删除用户
 */
@PreAuthorize("@ss.hasPermi('system:user:remove')")
@Log(title = "用户管理", businessType = BusinessType.DELETE)
@DeleteMapping("/{userIds}")
public Result remove(@PathVariable Long[] userIds) {
    if (ArrayUtils.contains(userIds, getUserId())) {
        return error("当前用户不能删除");
    }
    return toAjax(userService.deleteUserByIds(userIds));
}

②. 自定义权限实现
@PreAuthorize(“@ss.hasPermi(‘system:user:remove’)”)的意思是什么？

• A. ss 是一个注册在 Spring容器中的BEAN，对应的类是cn.hadoopx.framework.web.service.PermissionService；
• B. hasPermi 是PermissionService类中定义的方法；
• C.当Spring EL 表达式返回TRUE，则权限校验通过；
• D. PermissionService.java的定义如下：
   

/**
 * 自定义权限实现，ss取自SpringSecurity首字母
 * @author ROCKY
 */
@Service("ss")
public class PermissionService {
    /**
     * 所有权限标识
     */
    private static final String ALL_PERMISSION = "*:*:*";

    /**
     * 管理员角色权限标识
     */
    private static final String SUPER_ADMIN = "admin";
    private static final String ROLE_DELIMETER = ",";
    private static final String PERMISSION_DELIMETER = ",";

    /**
     * 验证用户是否具备某权限
     * @param permission 权限字符串
     * @return 用户是否具备某权限
     */
    public boolean hasPermi(String permission) {
        if (StringUtils.isEmpty(permission)) {
            return false;
        }
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (StringUtils.isNull(loginUser) || CollectionUtils.isEmpty(loginUser.getPermissions())) {
            return false;
        }
        return hasPermissions(loginUser.getPermissions(), permission);
    }

    /**
     * 验证用户是否不具备某权限，与 hasPermi逻辑相反
     * @param permission 权限字符串
     * @return 用户是否不具备某权限
     */
    public boolean lacksPermi(String permission) {
        return hasPermi(permission) != true;
    }

    /**
     * 验证用户是否具有以下任意一个权限
     * @param permissions 以 PERMISSION_NAMES_DELIMETER 为分隔符的权限列表
     * @return 用户是否具有以下任意一个权限
     */
    public boolean hasAnyPermi(String permissions) {
        if (StringUtils.isEmpty(permissions)) {
            return false;
        }
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (StringUtils.isNull(loginUser) || CollectionUtils.isEmpty(loginUser.getPermissions())) {
            return false;
        }
        Set<String> authorities = loginUser.getPermissions();
        for (String permission : permissions.split(PERMISSION_DELIMETER)) {
            if (permission != null && hasPermissions(authorities, permission)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断用户是否拥有某个角色
     * @param role 角色字符串
     * @return 用户是否具备某角色
     */
    public boolean hasRole(String role) {
        if (StringUtils.isEmpty(role)) {
            return false;
        }
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (StringUtils.isNull(loginUser) || CollectionUtils.isEmpty(loginUser.getUser().getRoles())) {
            return false;
        }
        for (SysRole sysRole : loginUser.getUser().getRoles()) {
            String roleKey = sysRole.getRoleKey();
            if (SUPER_ADMIN.equals(roleKey) || roleKey.equals(StringUtils.trim(role))) {
                return true;
            }
        }
        return false;
    }

    /**
     * 验证用户是否不具备某角色，与 isRole逻辑相反。
     * @param role 角色名称
     * @return 用户是否不具备某角色
     */
    public boolean lacksRole(String role) {
        return hasRole(role) != true;
    }

    /**
     * 验证用户是否具有以下任意一个角色
     * @param roles 以 ROLE_NAMES_DELIMETER 为分隔符的角色列表
     * @return 用户是否具有以下任意一个角色
     */
    public boolean hasAnyRoles(String roles) {
        if (StringUtils.isEmpty(roles)) {
            return false;
        }
        LoginUser loginUser = SecurityUtils.getLoginUser();
        if (StringUtils.isNull(loginUser) || CollectionUtils.isEmpty(loginUser.getUser().getRoles())) {
            return false;
        }
        for (String role : roles.split(ROLE_DELIMETER)) {
            if (hasRole(role)) {
                return true;
            }
        }
        return false;
    }

    /**
     * 判断是否包含权限
     * @param permissions 权限列表
     * @param permission  权限字符串
     * @return 用户是否具备某权限
     */
    private boolean hasPermissions(Set<String> permissions, String permission) {
        return permissions.contains(ALL_PERMISSION) || permissions.contains(StringUtils.trim(permission));
    }
}

7. Spring Boot

---

参考：

推荐收藏系列：Spring boot 2.x注解Annotation大全（持续更新....）-阿里云开发者社区