@Configuration
public class AuthorizationServerConfig {

    // 定义自定义同意页面 URI
    private static final String CUSTOM_CONSENT_PAGE_URI = "/oauth2/consent";

    // 配置授权服务器安全过滤器链
    @Bean
    @Order(1)
    public SecurityFilterChain authorizationServerSecurityFilterChain(HttpSecurity http)
            throws Exception {
        // 针对 Spring Authorization Server 最佳实践配置
        // 应用默认的 Spring 授权服务器安全配置
        OAuth2AuthorizationServerConfiguration.applyDefaultSecurity(http);

        http.getConfigurer(OAuth2AuthorizationServerConfigurer.class)
                .authorizationEndpoint(authorizationEndpoint ->
                        authorizationEndpoint.consentPage(CUSTOM_CONSENT_PAGE_URI))
                .oidc(oidc -> oidc
                        .userInfoEndpoint(userInfo -> userInfo
                                .userInfoResponseHandler(this::onAuthenticationSuccess)
                        )
                );    // 启用 OpenID Connect 1.0
        http
                // Redirect to the login page when not authenticated from the
                // authorization endpoint
                // 未经身份验证时重定向到登录页面
                .exceptionHandling((exceptions) -> exceptions
                        .defaultAuthenticationEntryPointFor(
                                new LoginUrlAuthenticationEntryPoint("/login"), // 配置登录地址
                                new MediaTypeRequestMatcher(MediaType.TEXT_HTML)
                        )
                )
                // Accept access tokens for User Info and/or Client Registration
                // 接受用户信息和/或客户端注册的访问令牌
                .oauth2ResourceServer((resourceServer) -> resourceServer
                        .jwt(Customizer.withDefaults()))
                .cors(Customizer.withDefaults());

        return http.build();
    }

    // 注册客户端存储库
    @Bean
    public RegisteredClientRepository registeredClientRepository() {
        // 注册用户平台客户端
        RegisteredClient wordPress = RegisteredClient.withId(UUID.randomUUID().toString())
                .clientId("kil-test") // 客户端ID
                .clientName("TOY") // 客户端名称
                .clientSecret("{noop}test") // 客户端密钥，{noop}表示明文存储
                .clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC) // 客户端认证方法
                .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE) // 授权类型：授权码模式
                .authorizationGrantType(AuthorizationGrantType.REFRESH_TOKEN) // 刷新令牌授权类型
                .authorizationGrantType(AuthorizationGrantType.CLIENT_CREDENTIALS) // 客户端凭据授权类型
                .redirectUri("https://blog.122345.xyz") // 授权码回调地址
                .postLogoutRedirectUri("https://blog.122345.xyz/") // 注销后重定向地址
                .scope("profile") // 客户端作用域
                // 令牌设置：访问令牌的生存期为1天
                .tokenSettings(TokenSettings.builder().accessTokenTimeToLive(Duration.ofDays(1L)).build())
                // 客户端设置：需要用户授权同意
                .clientSettings(ClientSettings.builder().requireAuthorizationConsent(true).build())
                .build(); // 构建注册的客户端

        return new InMemoryRegisteredClientRepository(wordPress);
    }

    // 定义一个名为jwtTokenCustomizer的Bean，用于定制JWT令牌
    @Bean
    public OAuth2TokenCustomizer<JwtEncodingContext> jwtTokenCustomizer() {
        // 返回一个Lambda表达式，定制JWT令牌的内容
        return (context) -> {
            // 检查令牌类型是否为访问令牌
            if (OAuth2TokenType.ACCESS_TOKEN.equals(context.getTokenType())) {
                // 获取JWT令牌的声明部分
                context.getClaims().claims((claims) -> {
                    // 获取用户权限列表并转换为Set集合
                    Set<String> roles = AuthorityUtils.authorityListToSet(context.getPrincipal().getAuthorities())
                            .stream()
                            // 将权限中的"ROLE_"前缀去除
                            .map(c -> c.replaceFirst("^ROLE_", ""))
                            // 转换为不可变的Set集合
                            .collect(Collectors.collectingAndThen(Collectors.toSet(), Collections::unmodifiableSet));

                    // 将角色信息放入JWT令牌的声明中的"roles"字段
                    claims.put("roles", roles);
                });
            }
        };
    }

    // 定义一个名为jwkSource的Bean，用于提供JSON Web Key (JWK)
    @Bean
    public JWKSource<SecurityContext> jwkSource() {
        // 生成RSA密钥对
        KeyPair keyPair = generateRsaKey();
        // 获取公钥
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
        // 获取私钥
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();
        // 创建RSAKey对象
        RSAKey rsaKey = new RSAKey.Builder(publicKey)
                // 设置私钥
                .privateKey(privateKey)
                // 设置Key ID
                .keyID(UUID.randomUUID().toString())
                // 构建RSAKey对象
                .build();
        // 创建JWKSet对象，包含上面创建的RSAKey
        JWKSet jwkSet = new JWKSet(rsaKey);
        // 返回一个不可变的JWKSet
        return new ImmutableJWKSet<>(jwkSet);
    }

    // 定义一个静态方法用于生成RSA密钥对
    private static KeyPair generateRsaKey() {
        // 声明KeyPair对象
        KeyPair keyPair;
        try {
            // 获取RSA算法的密钥对生成器实例
            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA");
            // 初始化密钥对生成器，指定密钥长度为2048位
            keyPairGenerator.initialize(2048);
            // 生成RSA密钥对
            keyPair = keyPairGenerator.generateKeyPair();
            // 捕获可能的异常
        } catch (Exception ex) {
            // 抛出异常
            throw new IllegalStateException(ex);
        }
        // 返回生成的RSA密钥对
        return keyPair;
    }

    // 定义一个名为jwtDecoder的Bean，接受一个JWKSource<SecurityContext>作为参数
    @Bean
    public JwtDecoder jwtDecoder(JWKSource<SecurityContext> jwkSource) {
        // 调用OAuth2AuthorizationServerConfiguration类的jwtDecoder方法，并传入jwkSource作为参数
        return OAuth2AuthorizationServerConfiguration.jwtDecoder(jwkSource);
    }

    // 定义一个名为authorizationServerSettings的Bean
    @Bean
    public AuthorizationServerSettings authorizationServerSettings() {
        // 使用AuthorizationServerSettings的构建器模式创建一个实例并返回
        return AuthorizationServerSettings.builder().build();
    }

    // 授权成功返回信息
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException {
        // 当认证成功时执行的方法，接受HttpServletRequest、HttpServletResponse和Authentication作为参数
        // 将Authentication转换为OidcUserInfoAuthenticationToken类型，以便获取用户信息

        // 设置响应的Content-Type为application/json，并指定字符集为UTF-8
        response.setContentType("application/json;charset=UTF-8");
        // 设置响应的状态码为200（HttpStatus.OK.value()返回的是200）
        response.setStatus(HttpStatus.OK.value());
        // 将request中的用户主体信息转换为JSON字符串并写入响应的输出流中
        response.getWriter().write(JSON.toJSONString(request.getUserPrincipal()));
        // 刷新响应的输出流
        response.getWriter().flush();
    }

}

@EnableWebSecurity
@Configuration(proxyBeanMethods = false) //不使用代理来优化 @Configuration 类中的 @Bean 方法
public class DefaultSecurityConfig {

    @Bean
    @Order(2)
    public SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http)
            throws Exception {
        // 定义一个安全过滤器链，指定顺序为2
        http
                .authorizeHttpRequests((authorize) -> authorize
                        // 配置不需要验证的地址
                        .requestMatchers(new AntPathRequestMatcher("/actuator/**"),
                                new AntPathRequestMatcher("/oauth2/**"),
                                new AntPathRequestMatcher("/login"),
                                new AntPathRequestMatcher("/**/*.json"),
                                new AntPathRequestMatcher("/**/*.html"),
                                // 对指定的地址不进行认证，允许所有访问
                                new AntPathRequestMatcher("/**/*.png")).permitAll()
                        // 其他地址需要认证
                        .anyRequest().authenticated()
                )
                // 启用默认的跨域配置
                .cors(Customizer.withDefaults())
                // 禁用CSRF保护
                .csrf(AbstractHttpConfigurer::disable)
//                .httpBasic(Customizer.withDefaults())
//           Form login handles the redirect to the login page from the
//           authorization server filter chain
                // 启用HTTP基本认证，使用默认配置
                // 登录的url
                .formLogin(form -> form
                        // 登录的url
                        .loginPage("/login")
                        // 指定用于处理登录的URL
                        .loginProcessingUrl("/login"))
        ;

        // 构建并返回SecurityFilterChain
        return http.build();
    }

    // 跨域请求配置
    @Bean
    public CorsConfigurationSource corsConfigurationSource() {
        // 定义跨域配置源
        UrlBasedCorsConfigurationSource source = new UrlBasedCorsConfigurationSource();
        CorsConfiguration config = new CorsConfiguration();
        // 允许所有头部
        config.addAllowedHeader("*");
        // 允许所有方法
        config.addAllowedMethod("*");
        // 允许所有来源
        config.addAllowedOriginPattern("*");
        // 允许发送身份验证信息
        config.setAllowCredentials(true);
        // 预检请求的有效期，单位为秒
        config.setMaxAge(3600L);
        // 对所有路径应用上述配置
        source.registerCorsConfiguration("/**", config);
        // 返回配置源
        return source;
    }
}

    // 注册客户端存储库
    @Bean
    public RegisteredClientRepository registeredClientRepository(JdbcTemplate jdbcTemplate) {

/*
        // 注册用户平台客户端
        RegisteredClient wordPress = RegisteredClient.withId(UUID.randomUUID().toString())
                .clientId("kil-blog") // 客户端ID
                .clientName("TOY论坛") // 客户端名称
                .clientSecret("{noop}kilCat") // 客户端密钥，{noop}表示明文存储
                .clientAuthenticationMethod(ClientAuthenticationMethod.CLIENT_SECRET_BASIC) // 客户端认证方法
                .authorizationGrantType(AuthorizationGrantType.AUTHORIZATION_CODE) // 授权类型：授权码模式
                .authorizationGrantType(AuthorizationGrantType.REFRESH_TOKEN) // 刷新令牌授权类型
                .authorizationGrantType(AuthorizationGrantType.CLIENT_CREDENTIALS) // 客户端凭据授权类型
                .redirectUri("https://blog.122345.xyz") // 授权码回调地址
                .postLogoutRedirectUri("https://blog.122345.xyz") // 注销后重定向地址
                .scope(OidcScopes.OPENID)
                .scope(OidcScopes.PROFILE)
                .scope("message.read")
                .scope("message.write")
                .scope("all") // 客户端作用域
                // 令牌设置：访问令牌的生存期为1天
                .tokenSettings(TokenSettings.builder().accessTokenTimeToLive(Duration.ofDays(1L)).build())
                // 客户端设置：需要用户授权同意
                .clientSettings(ClientSettings.builder().requireAuthorizationConsent(true).build())
                .build(); // 构建注册的客户端
*/

        // Save registered client's in db as if in-memory
        // registeredClientRepository.save(wordPress);

        return new JdbcRegisteredClientRepository(jdbcTemplate);
    }

    @Bean
    public JdbcOAuth2AuthorizationService auth2AuthorizationService(JdbcTemplate jdbcTemplate,
                                                                    RegisteredClientRepository registeredClientRepository) {
        // 这个 Bean 用于管理 OAuth2 授权。
        // 它需要两个参数：jdbcTemplate 和 registeredClientRepository。
        // jdbcTemplate 是 Spring JDBC 模板，用于执行 SQL 查询和更新操作。
        // registeredClientRepository 是一个接口，用于管理 OAuth2 客户端的注册信息。
        // 这个 Bean 将 OAuth2 授权信息存储到数据库中，并提供查询和删除授权信息的方法。
        return new JdbcOAuth2AuthorizationService(jdbcTemplate, registeredClientRepository);
    }

    @Bean
    public JdbcOAuth2AuthorizationConsentService auth2AuthorizationConsentService(JdbcTemplate jdbcTemplate,
                                                                                  RegisteredClientRepository registeredClientRepository) {
        // 这个 Bean 用于管理 OAuth2 授权同意。
        // 它也需要 jdbcTemplate 和 registeredClientRepository 作为参数。
        // 这个 Bean 将 OAuth2 授权同意信息存储到数据库中，并提供查询和删除授权同意信息的方法。
        // 它将被 ConsentController 使用。
        return new JdbcOAuth2AuthorizationConsentService(jdbcTemplate, registeredClientRepository);
    }

public String getDetails(
    @RequestParam(value="param1", required=true) String param1,
        @RequestParam(value="param2", required=false) String param2){
...
}

@RequestMapping("/hello/{id}")

    public String getDetails(@PathVariable(value="id") String id,

    @RequestParam(value="param1", required=true) String param1,

    @RequestParam(value="param2", required=false) String param2){

.......

}

@RestControllerAdvice
public class GlobalExceptionHandler {

    //默认全局异常处理
    @ExceptionHandler(Exception.class)
    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
    public ResultData<String> exception(Exception e){
        return ResultData.fail(ReturnCode.RC500.getCode(), e.getMessage());
    }

    // 自定义错误异常处理
    @ExceptionHandler(ServiceException.class)
    public ResultData<String> serviceException(ServiceException e){
        return ResultData.fail(e.getCode(), e.getMessage());
    }
}

@ExceptionHandler(value = MyException.class) -- 注解类型
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR) -- 错误码
@ResponseBody --  返回json
@ControllerAdvice -- 顾名思义，这是一个增强的 Controller。使用这个 Controller ，可以实现三个方面的功能：
1.全局异常处理
2.全局数据绑定
3.全局数据预处理

@Getter
public enum ReturnCode {
    RC100(100, "操作成功"),
    RC999(999, "操作失败"),
    RC200(200, "服务开启限流保护，请稍后再试！"),
    RC201(201, "服务开启降级保护，请稍后再试！"),
    RC202(202, "热点参数限流，请稍后再试！"),
    RC203(203, "系统规则不满足要求，请稍后再试！"),
    RC204(204, "系统规则不通过，请稍后再试！"),
    RC403(403, "无访问权限，请联系管理员授予权限"),
    RC401(401, "匿名用户访问无权限资源异常"),
    RC500(500, "系统错误，请稍后重试"),

    INVALID_TOKEN(2001, "访问令牌不合法"),
    ACCESS_DENIED(2003, "没有权限访问该资源"),
    CLIENT_AUTHENTICATION_FAILED(1001, "客户端认证失败"),
    USERNAME_OR_PASSWORD_ERROR(1002, "用户名或密码错误"),
    UNSUPPORTED_GRANT_TYPE(1003, "不支持的认证模式");

    private final int code;
    private final String message;
    ReturnCode(int code, String message){
        this.code = code;
        this.message = message;
    }
}

@Getter
public class ServiceException extends RuntimeException{

    // 错误码
    private final int code;

    // 通过自定义枚举类设置错误信息
    public ServiceException(ReturnCode returnCode){
        super(returnCode.getMessage());
        this.code = returnCode.getCode();
    }

    public ServiceException(Integer code, String message){
        super(message);
        this.code = code;
    }
}

@Data
public class ResultData<T> {
    private int status;
    private String message;
    private T data;
    private long timestamp;

    public ResultData(){
        this.timestamp = System.currentTimeMillis();
    }

    public static <T> ResultData<T> success(T data){
        ResultData<T> resultData = new ResultData<>();
        resultData.setStatus(ReturnCode.RC100.getCode());
        resultData.setMessage(ReturnCode.RC100.getMessage());
        resultData.setData(data);
        return resultData;
    }

    public static <T> ResultData<T> fail(int code, String message){
        ResultData<T> resultData = new ResultData<>();
        resultData.setStatus(code);
        resultData.setMessage(message);
        return resultData;
    }
}

@GetMapping("/info/{attrId}")
public ProductAttr getAttrIdById(@PathVariable("attrId") Long attrId){
    // throw new ServiceException(ReturnCode.INVALID_TOKEN); //抛出自定义异常
    int i = 10 / 0;
    return productAttrService.getById(attrId);
}

public interface ResponseBodyAdvice<T> {

    // 是否支持advice功能
    // true 支持，false 不支持
    boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType);

    // 对返回数据进行处理
    @Nullable
    T beforeBodyWrite(@Nullable T body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response);
}

@RestControllerAdvice
public class ResponseAdvice implements ResponseBodyAdvice<Object> {

    @Resource
    private ObjectMapper objectMapper;

    @Override
    public boolean supports(@NonNull MethodParameter returnType, @NonNull Class<? extends HttpMessageConverter<?>> converterType) {
        // 判断是否要执行beforeBodyWrite方法，true为执行，false不执行
        return true;
    }
    
    // 对response处理的执行方法
    @SneakyThrows
    @Override
    public Object beforeBodyWrite(Object body, @NonNull MethodParameter returnType, @NonNull MediaType selectedContentType, @NonNull Class<? extends HttpMessageConverter<?>> selectedConverterType, @NonNull ServerHttpRequest request, @NonNull ServerHttpResponse response) {
        // String类型不能直接包装，所以要进行些特别的处理
        if (body instanceof String){
            // 将数据包装在BaseResult里后，再转换为json字符串响应给前端
            return objectMapper.writeValueAsString(ResultData.success(body));
        }
        // 已经封装则直接返回
        if (body instanceof ResultData){
            return body;
        }
        // 将原本的数据包装ResultData在里
        return ResultData.success(body);
    }
}

@Data
public class ResultData<T> {
    private int status;
    private String message;
    private T data;
    private long timestamp;

    public ResultData(){
        this.timestamp = System.currentTimeMillis();
    }

    public static <T> ResultData<T> success(T data){
        ResultData<T> resultData = new ResultData<>();
        resultData.setStatus(ReturnCode.RC100.getCode());
        resultData.setMessage(ReturnCode.RC100.getMessage());
        resultData.setData(data);
        return resultData;
    }

    public static <T> ResultData<T> fail(int code, String message){
        ResultData<T> resultData = new ResultData<>();
        resultData.setStatus(code);
        resultData.setMessage(message);
        return resultData;
    }
}

@Getter
public enum ReturnCode {
    RC100(100, "操作成功"),
    RC999(999, "操作失败"),
    RC200(200, "服务开启限流保护，请稍后再试！"),
    RC201(201, "服务开启降级保护，请稍后再试！"),
    RC202(202, "热点参数限流，请稍后再试！"),
    RC203(203, "系统规则不满足要求，请稍后再试！"),
    RC204(204, "系统规则不通过，请稍后再试！"),
    RC403(403, "无访问权限，请联系管理员授予权限"),
    RC401(401, "匿名用户访问无权限资源异常"),
    RC500(500, "系统错误，请稍后重试"),

    INVALID_TOKEN(2001, "访问令牌不合法"),
    ACCESS_DENIED(2003, "没有权限访问该资源"),
    CLIENT_AUTHENTICATION_FAILED(1001, "客户端认证失败"),
    USERNAME_OR_PASSWORD_ERROR(1002, "用户名或密码错误"),
    UNSUPPORTED_GRANT_TYPE(1003, "不支持的认证模式");

    private final int code;
    private final String message;
    ReturnCode(int code, String message){
        this.code = code;
        this.message = message;
    }
}

@RestController
@RequestMapping("/product/attr")
public class ProductController {

    @Resource
    private ProductAttrService productAttrService;

    @GetMapping("/info/{attrId}")
    public ProductAttr getAttrIdById(@PathVariable("attrId") Long attrId){
        return productAttrService.getById(attrId);
    }

}

package cn.kil.springboot_parameter.service;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

/**
 * @program: springboot_parameter
 * @ClassName: UserService
 * @description:
 * @author: toy
 * @create: 2022-07-20 19:51
 */
@Service
@PropertySource("my.properties")
public class UserService {

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

    public void test(){
        System.out.println(name);
    }
}

package cn.kil.springboot_parameter;

import cn.kil.springboot_parameter.service.UserService;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.PropertySource;

@SpringBootApplication
public class SpringbootParameterApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext applicationContext = SpringApplication.run(SpringbootParameterApplication.class, args);
        UserService bean = applicationContext.getBean(UserService.class);
        bean.test();
    }
}

package cn.kil.springboot_parameter.properties;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * @program: springboot_parameter
 * @ClassName: MyProperties
 * @description: 我的配置
 * @author: toy
 * @create: 2022-07-20 19:50
 */
@Component
@ConfigurationProperties(prefix = "kil")
public class MyProperties {

    private String name;

    public String getName() {
        return name;
    }

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

package cn.kil.springboot_parameter.service;

import cn.kil.springboot_parameter.properties.MyProperties;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * @program: springboot_parameter
 * @ClassName: UserService
 * @description:
 * @author: toy
 * @create: 2022-07-20 19:51
 */
@Service
public class UserService {

    @Autowired
    private MyProperties myProperties;

    public void test(){
        System.out.println(myProperties.getName());
    }
}

import cn.kil.springboot_parameter.properties.MyProperties;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Configuration;

/**
 * @program: springboot_parameter
 * @ClassName: AppConfig
 * @description:
 * @author: toy
 * @create: 2022-07-20 23:56
 */
@Configuration
@EnableConfigurationProperties(MyProperties.class)
public class AppConfig {

}

package cn.kil.springboot_parameter;

import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
import org.springframework.context.annotation.Configuration;

/**
 * @program: springboot_parameter
 * @ClassName: AppConfig
 * @description:
 * @author: toy
 * @create: 2022-07-20 23:56
 */
@Configuration
@ConfigurationPropertiesScan("cn.kil.springboot_parameter.properties")
public class AppConfig {

}

package cn.kil.springboot_mybatis.mapper;

import cn.kil.springboot_mybatis.pojo.User;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper
public interface UserMapper {
    public List<User> getAllUserList();
}

package cn.kil.springboot_mybatis.pojo;

import java.util.Date;

/**
 * @program: kivm
 * @ClassName: User
 * @description: 用户
 * @author: toy
 * @create: 2022-05-19 20:00
 */
public class User {
    private int uid;
    private String username;
    private String password;
    private String email;
    private String phone;
    private String icon;
    private Date createTime;
    private int status;

    public User() {
    }

    public User(int uid, String username, String password, String email, String phone, String icon, Date createTime, int status) {
        this.uid = uid;
        this.username = username;
        this.password = password;
        this.email = email;
        this.phone = phone;
        this.icon = icon;
        this.createTime = createTime;
        this.status = status;
    }

    public int getUid() {
        return uid;
    }

    public void setUid(int uid) {
        this.uid = uid;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPhone() {
        return phone;
    }

    public void setPhone(String phone) {
        this.phone = phone;
    }

    public String getIcon() {
        return icon;
    }

    public void setIcon(String icon) {
        this.icon = icon;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }

    @Override
    public String toString() {
        return "User{" +
                "uid=" + uid +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", email='" + email + '\'' +
                ", phone='" + phone + '\'' +
                ", icon='" + icon + '\'' +
                ", createTime=" + createTime +
                ", status=" + status +
                '}';
    }
}

//注意是*开头，不是/**开头.  方法注释模板中的参数是 $ $, 而类中的是${ }. 
*
 * @description: $description$
 * @Date: $DATE$ $TIME$
 * @Param: $param$
 * @Return: $return$
*/