Spring备忘

• spring - 统一的异常处理

  @Controller
  public class BaseController {
      protected final static Logger logger = LoggerFactory
              .getLogger("controller");
  
      @ResponseBody
      @ExceptionHandler(Exception.class)
      public RespBody exceptionHandler(Exception ex) {
          return RespBody.error("exception", ex.getMessage());
      }
  }

   如果Controller中没有@ExceptionHandler异常处理, 则会从父类中查找.
• spring4 - @RestController
• spring4 - 泛型限定式依赖注入

  /** Bean */
  public class User implements Serializable {
      private Long id;
      private String name;
  }
  
  public class Organization implements Serializable {
      private Long id;
      private String name;
  }
  
  /** Repository */
  public abstract class BaseRepository<M extends Serializable> {
      public void save(M m) {
          System.out.println("=====repository save:" + m);
      }
  }
  
  @Repository
  public class UserRepository extends BaseRepository<User> {
  }
  
  @Repository
  public class OrganizationRepository extends BaseRepository<Organization> {
  }
  
  /** Service */
  public abstract class BaseService<M extends Serializable> {
      @Autowired
      protected BaseRepository<M> repository; // 在这里通过泛型,实现了自动依赖注入
      
      public void save(M m) {
          repository.save(m);
      }
  }
  
  @Service
  public class UserService extends BaseService<User> {
  }
  
  @Service
  public class OrganizationService extends BaseService<Organization> {
  }

• spring4 - AsyncRestTemplate 

  /** Server */
  @RestController
  public class UserController {
      private UserService userService;
      @Autowired
      public UserController(UserService userService) {
          this.userService = userService;
      }
      @RequestMapping("/api")
        public Callable<User> api() {
          System.out.println("=====hello");
          return new Callable<User>() {
              @Override
              public User call() throws Exception {
                  Thread.sleep(10L * 1000); //暂停两秒
                  User user = new User();
                  user.setId(1L);
                  user.setName("haha");
                  return user;
              }
          };
      }
  }

   

  /** Client */
      public static void main(String[] args) {
          AsyncRestTemplate template = new AsyncRestTemplate();
          //调用完后立即返回（没有阻塞）
          ListenableFuture<ResponseEntity<User>> future = template.getForEntity("http://localhost:9080/spring4/api", User.class);
          //设置异步回调
          future.addCallback(new ListenableFutureCallback<ResponseEntity<User>>() {
              @Override
              public void onSuccess(ResponseEntity<User> result) {
                  System.out.println("======client get result : " + result.getBody());
              }
  
              @Override
              public void onFailure(Throwable t) {
                  System.out.println("======client failure : " + t);
              }
          });
          System.out.println("==no wait");
      }

   
• @Conditional