Taogen's Blog

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.std.StdSerializer;
import com.taogen.demo.modules.task.enumeration.NameValueEnum;

import java.io.IOException;

/**
 * Serializing Enums to JSON
 */
public class NameValueEnumSerializer extends StdSerializer<NameValueEnum> {

    protected NameValueEnumSerializer() {
        super(NameValueEnum.class);
    }

    protected NameValueEnumSerializer(Class t) {
        super(t);
    }

    @Override
    public void serialize(NameValueEnum nameValueEnum, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        jsonGenerator.writeStartObject();
        jsonGenerator.writeFieldName("name");
        jsonGenerator.writeString(nameValueEnum.getName());
        jsonGenerator.writeFieldName("value");
        jsonGenerator.writeString(nameValueEnum.getValue());
        jsonGenerator.writeEndObject();
    }
}

public interface NameValueEnum {

    public String getName();

    public void setName(String name);

    public String getValue();

    public void setValue(String value);
}

@JsonSerialize(using = NameValueEnumSerializer.class)
public enum TaskPriority implements NameValueEnum {
    EMERGENCY("emergency", "紧急"),
    HIGH("high", "高"),
    GENERAL("general", "普通"),
    LOW("low", "低")
    ;

    private String name;

    private String value;
    
	@Override
    @JsonValue
    public String getName() {
        return name;
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String getValue() {
        return value;
    }

    @Override
    public void setValue(String value) {
        this.value = value;
    }
}

public class Task extends BaseEntity {
    private TaskPriority priority;
}

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;

import java.io.IOException;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

public class CommaSeparatedStrToListJsonDeserializer
        extends JsonDeserializer<List<String>> {

    @Override
    public List<String> deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
        if ("{specifiedField}".equals(jsonParser.currentName())) {
            String fieldStr = jsonParser.getValueAsString();
            if (fieldStr != null && !fieldStr.trim().isEmpty()) {
                return Arrays.stream(fieldStr.split(",")).collect(Collectors.toList());
            }
        }
        return null;
    }
}

@JsonDeserialize(using = CommaSeparatedStrToListJsonDeserializer.class)
private List<String> {specifiedField};

public class JsonArrayToStringDeserializer extends JsonDeserializer<String> {
    @Override
    public String deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException {
       if (jsonParser.currentToken() == JsonToken.START_ARRAY) {
           List<String> list = new ArrayList<>();
           jsonParser.nextToken();

           while (jsonParser.hasCurrentToken() && jsonParser.currentToken() != JsonToken.END_ARRAY) {
              list.add(jsonParser.getValueAsString());
              jsonParser.nextToken();
           }
          return String.join(",", list);
       }
       return null;
    }
}

@JsonDeserialize(using = JsonArrayToStringDeserializer.class)
private String {specifiedField};

@Autowired
private MyMapper mapper;

@Repository
public interface MyMapper {}

@Resouce
private MyMapper mapper;

@Deprecated // programmers are discouraged from using, typically because it is dangerous, or because a better alternative exists.
@FunctionalInterface
@Override // Indicates that a method declaration is intended to override a method declaration in a supertype.
@SuppressWarnings // Indicates that the named compiler warnings should be suppressed in the annotated element (and in all program elements contained in the annotated element).
@SafeVarargs // A programmer assertion that the body of the annotated method or constructor does not perform potentially unsafe operations on its varargs parameter.

@Component
@Controller
@Service
@Repository

@Profile("dev")

@Profile({"dev","test"})

// Only can contains one !string. Can't be like {"!dev","!test"}
@Profile("!dev")

@Autowired
@Resource

@Qualifier("specificBeanName")

@PostConstruct
public void init() {}

@PreDestroy
public void destroy() {}

@Configuration
@Bean
@ConditionalOnBean
@ConditionalOnMissingBean
@ConditionalOnProperty
@ConditionalOnResource
@ConditionalOnWebApplication
@ConditionalExpression
@Conditional

@PropertySource("classpath:my.properties")
public class MyProperties {}

@ConfigurationProperties(prefix = "config.path")
@Configuration
@EnableConfigurationProperties
@Data
public class MyProperties {}

@Value("${databaseName}")
private String databaseName;

@Controller
@RestController
@RequestMapping
@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

@PathVariable
@RequestParam
@RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") Date datetime
@RequestParam @DateTimeFormat(pattern = "HH:mm:ss") LocalTime time
@ModelAttribute
@RequestBody
@RequestHeader

@ResponseBody
@ResponseHeader
@ResponseStatus

/**
 * This method used in your Controller, 
 * or you can put the method in your BaseController.
 */
@InitBinder
public void initBinder(WebDataBinder binder)
{
	// Convert field type from string to Date
    binder.registerCustomEditor(Date.class, new PropertyEditorSupport()
    {
        @Override
        public void setAsText(String text)
        {
            setValue(DateUtils.parseDate(text));
        }
    });
}

@InitBinder
public void initBinder(WebDataBinder dataBinder) {
    dataBinder.registerCustomEditor(YourEnum.class, new YourEnumConverter());
}

@ExceptionHandler

@Transactional(rollbackFor=Exception.class)

@EnableWebSecurity

@SpringBootApplication

@MapperScan

@MapperScan({"com.demo.dao", "com.demo.modules.**.dao"})

@NotNull // a constrained CharSequence, Collection, Map, or Array is valid as long as it's not null, but it can be empty
@NotEmpty // a constrained CharSequence, Collection, Map, or Array is valid as long as it's not null and its size/length is greater than zero
@NotBlank // a constrained String is valid as long as it's not null and the trimmed length is greater than zero.
@Null
@Size // The annotated element size must be between the specified boundaries (included).
@Pattern // The annotated CharSequence must match the specified regular expression.
@Email

@Digits
@Min
@Max
@DecimalMax
@DecimalMin
@Positive
@PositiveOrZero
@Negative
@NegativeOrZero

@Future // The annotated element must be an instant, date or time in the future.
@FutureOrPresent
@Past // The annotated element must be an instant, date or time in the past.
@PastOrPresent

@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
private Date createTime;

@JsonProperty(value = "user_password")
private String userPassword;

@JsonIgnore // for field
@JsonIgnoreProperties({"fieldname1", "fieldname2"}) // for POJO class
@JsonInclude // annotation used to define if certain "non-values" (nulls or empty values) should not be included when serializing

@JsonSerialize(using = NameValueEnumSerializer.class)
public enum Type {
}

@DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private Date createTime;

@DateTimeFormat(pattern = "HH:mm:ss")
private LocalTime alertTime;

@JsonValue
public String getName() {
	return name;
}

@Entity
@Table
@Id
@GeneratedValue

@TableName("t_user")

@TableId(value = "id", type = IdType.AUTO)

@TableField(exist = false)

@TableField("`column`")
private String column;

@TableLogic(value = "0", delval = "1")
private Integer deleteFlag;

@Data
@Getter/@Setter
@ToString
@ToString(callSuper = true)
@NoArgsConstructor, @RequiredArgsConstructor and @AllArgsConstructor
@EqualsAndHashCode
@Builder // User.builder().name("Jack").build()

public NonNullExample(@NonNull Person person) {
	super("Hello");
	this.name = person.getName();
}

public NonNullExample(@NonNull Person person) {
	super("Hello");
	if (person == null) {
	  throw new NullPointerException("person is marked @NonNull but is null");
	}
	this.name = person.getName();
}

public static void main(String[] args) throws IOException {
    @Cleanup InputStream in = new FileInputStream(args[0]);
    @Cleanup OutputStream out = new FileOutputStream(args[1]);
    byte[] b = new byte[10000];
    while (true) {
      int r = in.read(b);
      if (r == -1) break;
      out.write(b, 0, r);
    }
}

@SneakyThrows(UnsupportedEncodingException.class)
public String utf8ToString(byte[] bytes) {
    return new String(bytes, "UTF-8");
}

public String utf8ToString(byte[] bytes) {
    try {
      return new String(bytes, "UTF-8");
    } catch (UnsupportedEncodingException e) {
      throw Lombok.sneakyThrow(e);
    }
}

@Log
@Log4j
@Log4j2
@Slf4j

private static final java.util.logging.Logger log = java.util.logging.Logger.getLogger(LogExample.class.getName());

private static final org.apache.log4j.Logger log = org.apache.log4j.Logger.getLogger(LogExample.class);

private static final org.apache.logging.log4j.Logger log = org.apache.logging.log4j.LogManager.getLogger(LogExample.class);

private static final org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(LogExample.class);

@Value
@Synchronized
@With
@Getter(lazy=true)
@RequiredArgsConstructor(onConstructor_ = @Autowired)