代码臃肿

lombok 描述
lombok 消除 POJO 冗长
validator 描述
validator 校验框架
mapstruct 描述
mapstruct 映射框架 
@Data
public class User {
    public String name;
    public Integer age;
}

@Data
public class Person {
    public String PersonName;
    public Integer PersonAge;
}

@Mapper
public interface PersonToUser {

    PersonToUser MAPPER = Mappers.getMapper(PersonToUser.class);

    @Mappings({ 
        @Mapping(target = "name", source = "PersonName"),
        @Mapping(target = "age", source = "PersonAge")
    })
    
    User personToUser(User user);

}

public static void main(String[] args) {
        
        User user = new User();
        user.setName("xx");
        user.setAge(18);
        
        User u = PersonToUser.MAPPER.personToUser(user);
        System.out.println(u);
    }
自定义注解 描述
@Target @Target表示 Annotation 所修饰的对象范围
@Retention @Retention表示Annotation声明周期，RUNTIME：运行时保留 
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Custom{
    String value();        //注解的属性，如果只有一个属性，一般叫value
    String name() default "";            //属性，默认值""，可以不写
}
spring AOP注解 描述
@Apsect 将当前类标识为一个切面
@Pointcut 定义切点，这里使用的是条件表达式
如： "execution(* com.travels.controller.AlipayController .groupOrderPay(..))" com.travels.controller.AlipayController代表调用类，groupOrderPay(..)代表调用方法，任意参数
如：@annotation(com.travels.controller.AlipayController.groupOrderPay) 匹配注解类
@Before 前置增强，就是在目标方法执行之前执行；
@AfterReturning 后置增强，方法退出时执行；
@AfterThrowing 有异常时该方法执行；
@AfterThrowing 有异常时该方法执行；
@After 最终增强，无论什么情况都会执行；
@Afround 环绕增强
三元表达式 描述
三元表达式 return a>b?a:b
Lambda表达式 描述
Lambda表达式 允许把函数作为一个方法的参数,简化匿名内部类
@FunctionalInterface 函数式接口:一个接口，然后就是在这个接口里面只能有一个抽象方法,加上了@FunctionInterface只能有一个抽象方法，否则编译器会报错
Supplier 提供者 指定一个泛型并返回
Consumer 消费者 指定一个泛型传入，没有返回值
Predicate 输入参数进行判断，然后返回布尔值
Function 两个参数，T输入 R输出 

@FunctionalInterface
public interface MyFunctional{
    void myFunctional();
}

public class MyFunctionalTest {
    public static void main(String[] args) {
        MyFunctional myFunctional = () -> System.out.println("myFunctional");
        myFunctional.myFunctional();
    }
}

@FunctionalInterface
public interface MyFunctional{
    String myFunctional();   //有返回值类型
}

public class MyFunctionalTest {
    public static void main(String[] args) {
        String str = "string";
        MyFunctional myFunctional = () -> {return str;};
        System.out.println(myFunctional.myFunctional());
    }
}

public class SupplierTest {
    public static String getString(Supplier<String> supplier) {
        return supplier.get();
    }

    public static void main(String[] args) {
        String str = getString(() -> {return "get string";});
        System.out.println(str);
    }
}

public class ConsumerTest {
    public static void consumerTest(String string,Consumer<String> con) {
        con.accept(string);
    }
    public static void main(String[] args) {
        String str = "Consumer... ";
        consumerTest(str, (String string) -> { System.out.println(str);});
    }
}

public class PredicateTest {
    public static Boolean check(String string,Predicate<String> pre) {
        return pre.test(string);
    }
    public static void main(String[] args) {
        String str = "true";
        Boolean bl = check(str, (String string) -> { return true;});
        System.out.println(bl);
    }
}

public class FunctionTest {
    
    public static int change(String string,Function<String, Integer> fun) {
        Integer integer = fun.apply(string);
        return integer;
    }
    
    public static void main(String[] args) {
        String str = "1";
        Integer integer = change(str, (String string) -> {return Integer.parseInt(str);});
        System.out.println(integer);
    }
}
Stream 描述
Stream 一种链式函数式编程，流终结了就不能再次操作，简化Collection集合操作
void forEach(Consumer<? super T> action); 用来便利，终结方法
Stream<T> filter(Predicate<? super T> predicate); 用于过滤，返回符合条件的元素
<R> Stream<R> map(Function<? super T, ? extends R> mapper); 输入一个参数，返回一个参数
long count(); 终结方法，返回元素个数
Stream<T> limit(long maxSize); 截取前n个元素
Stream<T> skip(long n); 跳过前n个元素 
public class StreamTest {
    
    public static void main(String[] args) {
        
        List<String> list = new ArrayList<String>();
        list.add("1");
        list.add("2");
        
        list.stream()
        .filter((String numeral) -> { return numeral.startsWith("1");})
        .map((String numeral) -> {return Integer.parseInt(numeral);}).limit(1)
        .forEach((Integer numeral) -> {System.out.println(numeral);});
        
    }
}
Filter 描述
Filter 过滤器
init 初始化
doFilter 拦截
destroy 消耗 
public class FilterTest implements Filter{
    
    @Override
        public void init(FilterConfig filterConfig) throws ServletException {
            // TODO Auto-generated method stub
            Filter.super.init(filterConfig);
        }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // TODO Auto-generated method stub
        
    }
    
    @Override
    public void destroy() {
        // TODO Auto-generated method stub
        Filter.super.destroy();
    }

}
过滤器 描述
HandlerInterceptor 接口
HandlerInterceptorAdapter 抽象类 Spring MVC封装
preHandle 方法调用前执行
postHandle 方法执行后调用
afterCompletion 请求处理完毕后回调 
public class HandlerInterceptorTest implements HandlerInterceptor{
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // TODO Auto-generated method stub
        return HandlerInterceptor.super.preHandle(request, response, handler);
    }
    
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
        // TODO Auto-generated method stub
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }
    
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        // TODO Auto-generated method stub
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}

public class HandlerInterceptorAdapterTest extends HandlerInterceptorAdapter{
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // TODO Auto-generated method stub
        return super.preHandle(request, response, handler);
    }
    
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
        // TODO Auto-generated method stub
        super.postHandle(request, response, handler, modelAndView);
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        // TODO Auto-generated method stub
        super.afterCompletion(request, response, handler, ex);
    }
}
异常处理 描述
异常处理 @RestControllerAdvice + @ExceptionHandler优化try catch 
public class MyException extends Exception {

    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    private String message;

    /**
     * 自定义异常
     * 
     * @param message ：异常描述
     */
    public MyException(String message) {
        this.message = message;
    }

}

@RestControllerAdvice
public class ExceptionResponseConfig {
    
    
    @ExceptionHandler(value = MyException.class)
    public Map<String, Object> myExceptionHandler(MyException exception) {
        return StateCode.getMap(StateCode.OPERATION_ERROR, exception.getMessage());
    }
    
    
    public void test() throws MyException
    {
        throw new MyException("自定义异常");
    }
}
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
【社区内容提示】社区部分内容疑似由AI辅助生成，浏览时请结合常识与多方信息审慎甄别。
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

相关阅读更多精彩内容

友情链接更多精彩内容