import org.apache.rocketmq.client.producer.DefaultMQProducer;
import org.apache.rocketmq.client.producer.MessageQueueSelector;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.common.message.Message;
import org.apache.rocketmq.remoting.common.RemotingHelper;

public class TransactionProducer {

    public static void main(String[] args) throws Exception {
        // 实例化消息生产者Producer
        DefaultMQProducer producer = new DefaultMQProducer("TransactionProducerGroup");
        // 设置NameServer的地址
        producer.setNamesrvAddr("localhost:9876");

        // 执行本地事务
        producer.setTransactionExecutor(new TransactionMQProducer.TransactionExecutor() {
            @Override
            public LocalTransactionState executeLocalTransactionBranch(Message msg, Object arg) {
                // 这里处理本地事务逻辑
                if (/* 本地事务成功 */) {
                    return LocalTransactionState.COMMIT_MESSAGE;
                } else if (/* 需要回滚 */) {
                    return LocalTransactionState.ROLLBACK_MESSAGE;
                } else {
                    return LocalTransactionState.UNKNOW;
                }
            }
        });

        // 启动Producer实例
        producer.start();

        // 创建一条消息对象，这里Hello World为消息内容，TagA为用户指定的标签，test为消息主题
        Message msg = new Message("TopicTest", "TagA", "Hello RocketMQ");

        // 发送消息
        SendResult sendResult = producer.send(msg, new MessageQueueSelector() {
            @Override
            public MessageQueue select(List<MessageQueue> mqs, Message msg, Object arg) {
                long id = (Long)arg;
                int index = (int)(id % mqs.size());
                return mqs.get(index);
            }
        }, 1L); // arg参数为1

        System.out.printf("%s%n", sendResult);
        // 如果不是UNKNOW状态，则不需要回调检查
        if (sendResult.getSendStatus() == SendStatus.SEND_OK && sendResult.getLocalTransactionState() != LocalTransactionState.UNKNOW) {
            producer.shutdown();
            return;
        }

        // 等待Broker的二次确认
        Thread.sleep(1000 * 5);

        producer.shutdown();
    }
}

@Override
public LocalTransactionState checkLocalTransactionState(Message message) {
    // 这里根据message的属性来决定是否提交或回滚消息
    if (/* 本地事务成功 */) {
        return LocalTransactionState.COMMIT_MESSAGE;
    } else {
        return LocalTransactionState.ROLLBACK_MESSAGE;
    }
}

public class CreateToken {
    public static Key key = Keys.hmacShaKeyFor("fanseafanseafanseafanseafanseafansesafansea".getBytes());

    public static void main(String[] args) {
        System.out.println(createToken());
    }
    public static String createToken(){
        return Jwts.builder()
                .setSubject("1")
                .claim("username", "fansea")
                .signWith(key)
                .compact();
    }
}

public class AnalysisToken {
    public static void main(String[] args) {
        String token = CreateToken.createToken();
        System.out.println(token);
        Claims claims = AnalysisToken.analysisToken(token);
        System.out.println("Subject:" + claims.getSubject());
        System.out.println("UserName:" + claims.get("username"));
    }

    private static Claims analysisToken(String token) {
        Key key = CreateToken.key;
        return Jwts.parserBuilder()
                .setSigningKey(key)
                .build()
                .parseClaimsJws(token)
                .getBody();
    }

public String createToken(LoginUser loginUser)
{
    String token = IdUtils.fastUUID();
    loginUser.setToken(token);
    setUserAgent(loginUser);
    refreshToken(loginUser);

    Map<String, Object> claims = new HashMap<>();
    claims.put(Constants.LOGIN_USER_KEY, token);
    return createToken(claims);
}

private String createToken(Map<String, Object> claims)
    {
        String token = Jwts.builder()
                .setClaims(claims)
                .signWith(SignatureAlgorithm.HS512, secret).compact();
        return token;
    }

public void setUserAgent(LoginUser loginUser)
    {
        UserAgent userAgent = UserAgent.parseUserAgentString(ServletUtils.getRequest().getHeader("User-Agent"));
        String ip = IpUtils.getIpAddr();
        loginUser.setIpaddr(ip);
        loginUser.setLoginLocation(AddressUtils.getRealAddressByIP(ip));
        loginUser.setBrowser(userAgent.getBrowser().getName());
        loginUser.setOs(userAgent.getOperatingSystem().getName());
    }

public void refreshToken(LoginUser loginUser)
    {
        loginUser.setLoginTime(System.currentTimeMillis());
        loginUser.setExpireTime(loginUser.getLoginTime() + expireTime * MILLIS_MINUTE);
        // 根据uuid将loginUser缓存
        String userKey = getTokenKey(loginUser.getToken());
        redisCache.setCacheObject(userKey, loginUser, expireTime, TimeUnit.MINUTES);
    }

public LoginUser getLoginUser(HttpServletRequest request)
    {
        // 获取请求携带的令牌
        String token = getToken(request);
        if (StringUtils.isNotEmpty(token))
        {
            try
            {
                Claims claims = parseToken(token);
                // 解析对应的权限以及用户信息
                String uuid = (String) claims.get(Constants.LOGIN_USER_KEY);
                String userKey = getTokenKey(uuid);
                LoginUser user = redisCache.getCacheObject(userKey);
                return user;
            }
            catch (Exception e)
            {
                log.error("获取用户信息异常'{}'", e.getMessage());
            }
        }
        return null;
    }

public class DataFetcher {
    public String fetchData() {
        // 模拟从网络获取数据
        return "Some data";
    }
}

public class UI {
    public void showData() {
        DataFetcher fetcher = new DataFetcher();
        String data = fetcher.fetchData();
        System.out.println("Displaying data: " + data);
    }
}

// 定义一个数据获取行为的接口
public interface IDataFetcher {
    String fetchData();
}

// 具体的数据获取实现
public class NetworkDataFetcher implements IDataFetcher {
    @Override
    public String fetchData() {
        // 模拟从网络获取数据
        return "Some data from the network";
    }
}

public class FileDataFetcher implements IDataFetcher {
    @Override
    public String fetchData() {
        // 模拟从文件读取数据
        return "Some data from a file";
    }
}

public class UI {
    private final IDataFetcher dataFetcher;

    // 通过构造函数传递依赖
    public UI(IDataFetcher dataFetcher) {
        this.dataFetcher = dataFetcher;
    }

    public void showData() {
        String data = dataFetcher.fetchData();
        System.out.println("Displaying data: " + data);
    }
}

interface IMoveable {
    void move();
    void fly(); // 飞行能力
    void swim(); // 游泳能力
}

class Animal implements IMoveable {
    public void move() {
        System.out.println("Animal is moving.");
    }

    public void fly() {
        System.out.println("Animal cannot fly.");
    }

    public void swim() {
        System.out.println("Animal cannot swim.");
    }
}

class Vehicle implements IMoveable {
    public void move() {
        System.out.println("Vehicle is moving.");
    }

    public void fly() {
        System.out.println("Vehicle can fly.");
    }

    public void swim() {
        System.out.println("Vehicle cannot swim.");
    }
}

interface IMovable {
    void move();
}

interface IFlyable {
    void fly();
}

interface ISwimmable {
    void swim();
}

class Animal implements IMovable {
    public void move() {
        System.out.println("Animal is moving.");
    }
}

class FlyingVehicle implements IMovable, IFlyable {
    public void move() {
        System.out.println("Flying Vehicle is moving.");
    }

    public void fly() {
        System.out.println("Flying Vehicle can fly.");
    }
}

class SwimmingVehicle implements IMovable, ISwimmable {
    public void move() {
        System.out.println("Swimming Vehicle is moving.");
    }

    public void swim() {
        System.out.println("Swimming Vehicle can swim.");
    }
}

public class Student {
    private String name;
    private Course course;

    public Student(String name, Course course) {
        this.name = name;
        this.course = course;
    }

    public String getName() {
        return name;
    }

    public double calculateTotalScore() {
        // 直接访问Course内部的Grades
        return course.getGrades().stream()
                     .mapToDouble(Grade::getScore)
                     .sum();
    }
}

public class Course {
    private List<Grade> grades;

    public Course(List<Grade> grades) {
        this.grades = grades;
    }

    public List<Grade> getGrades() {
        return grades;
    }
}

public class Grade {
    private double score;

    public Grade(double score) {
        this.score = score;
    }

    public double getScore() {
        return score;
    }
}

public class Student {
    private String name;
    private Course course;

    public Student(String name, Course course) {
        this.name = name;
        this.course = course;
    }

    public String getName() {
        return name;
    }

    public double calculateTotalScore() {
        // 通过Course的API来获取总分数
        return course.calculateScores();
    }
}

public class Course {
    private List<Grade> grades;

    public Course(List<Grade> grades) {
        this.grades = grades;
    }

    public double calculateScores() {
        // Course内部处理计算逻辑
        return grades.stream()
                    .mapToDouble(Grade::getScore)
                    .sum();
    }
}

public class Grade {
    private double score;

    public Grade(double score) {
        this.score = score;
    }

    public double getScore() {
        return score;
    }
}

public class UserHolder {
    private static final ThreadLocal<UserDTO> tl = new ThreadLocal<>();

    public static void saveUser(UserDTO user){
        tl.set(user);
    }

    public static UserDTO getUser(){
        return tl.get();
    }

    public static void removeUser(){
        tl.remove();
    }
}

public class RefreshInterceptor implements HandlerInterceptor {
    /*黑马点评项目中我们将用户信息保存在每一个请求线程ThreadLocal中，这样我们只需要在拦截器中获取用户信息，无需继续访问数据库*/
    private StringRedisTemplate stringRedisTemplate;

    public RefreshInterceptor(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        String token = request.getHeader("authorization");
        Map<Object, Object> userDtoMap = stringRedisTemplate.opsForHash()
                .entries("login:token:" + token);
        if (userDtoMap.isEmpty()) {
            return true;
        }
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userDtoMap, new UserDTO(), false);
        //存在，存入threadLocal中
        UserHolder.saveUser(userDTO);
        //刷新过期时间
        stringRedisTemplate.expire(LOGIN_USER + token,30, TimeUnit.MINUTES);
        //放行
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //销毁数据，防止用户信息泄露
        UserHolder.removeUser();
    }
}

private void remove(ThreadLocal<?> key) {
    //使用hash方式，计算当前ThreadLocal变量所在table数组位置
    Entry[] tab = table;
    int len = tab.length;
    int i = key.threadLocalHashCode & (len-1);
    //再次循环判断是否在为ThreadLocal变量所在table数组位置
    for (Entry e = tab[i];
         e != null;
         e = tab[i = nextIndex(i, len)]) {
        if (e.get() == key) {
            //调用WeakReference的clear方法清除对ThreadLocal的弱引用
            e.clear();
            //清理key为null的元素
            expungeStaleEntry(i);
            return;
        }
    }
}

import javax.servlet.*;
import java.io.IOException;

public class EncodingFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化代码
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // 在请求进入Controller之前处理
        System.out.println("EncodingFilter: Before processing");

        // 调用下一个过滤器或者最终的目标资源
        chain.doFilter(request, response);

        // 在请求返回给客户端之后处理
        System.out.println("EncodingFilter: After processing");
    }

    @Override
    public void destroy() {
        // 销毁代码
    }
}

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

public class LoginInterceptor extends HandlerInterceptorAdapter {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
        // 在调用控制器方法之前执行
        System.out.println("LoginInterceptor: Before processing");

        // 检查session中是否有用户信息
        if (request.getSession().getAttribute("user") == null) {
            // 如果没有，则重定向到登录页面
            response.sendRedirect("/login");
            return false;
        }
        return true; // 返回true则继续向下执行，否则结束
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
                           ModelAndView modelAndView) throws Exception {
        // 在调用控制器方法之后执行，但在视图渲染之前
        System.out.println("LoginInterceptor: After handling but before view rendering");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
        // 在整个请求完成后执行，包括视图渲染
        System.out.println("LoginInterceptor: After view rendering");
    }
}

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 注册拦截器
        registry.addInterceptor(new LoginInterceptor())
                .addPathPatterns("/**") // 拦截所有请求
                .excludePathPatterns("/login", "/logout"); // 排除/login和/logout路径
    }
}

@GetMapping("/bodyEmitter")
    public ResponseBodyEmitter handle() {
        // 创建一个ResponseBodyEmitter，-1代表不超时
        ResponseBodyEmitter emitter = new ResponseBodyEmitter(-1L);
        // 异步执行耗时操作
        CompletableFuture.runAsync(() -> {
            try {
                // 模拟耗时操作
                for (int i = 0; i < 10000; i++) {
                    System.out.println("bodyEmitter " + i);
                    // 发送数据
                    emitter.send("bodyEmitter " + i + " @ " + new Date() + "\n");
                    Thread.sleep(2000);
                }
                // 完成
                emitter.complete();
            } catch (Exception e) {
                // 发生异常时结束接口
                emitter.completeWithError(e);
            }
        });
        return emitter;
    }

public class MultiplexingServer {

    public static void main(String[] args) throws IOException {
        // 创建 Selector
        Selector selector = Selector.open();

        // 创建 ServerSocketChannel 并绑定到指定端口
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.socket().bind(new InetSocketAddress(8080));
        serverSocketChannel.configureBlocking(false);

        // 注册 ServerSocketChannel 到 Selector 上，监听 Accept 事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("Server started on port 8080");

        while (true) {
            // 选择一组已经就绪的通道
            selector.select();

            // 获取已选择的键集
            Iterator<SelectionKey> keys = selector.selectedKeys().iterator();

            while (keys.hasNext()) {
                SelectionKey key = keys.next();

                // 处理 Accept 事件
                if (key.isAcceptable()) {
                    ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
                    SocketChannel socketChannel = serverChannel.accept();
                    socketChannel.configureBlocking(false);
                    // 读状态：将管道的数据写到缓冲区之后再执行读操作（先写再读）
                    socketChannel.register(selector, SelectionKey.OP_READ);
                    System.out.println("Accepted connection from " + socketChannel.getRemoteAddress());
                }

                // 处理 Read 事件
                if (key.isReadable()) {
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int bytesRead = socketChannel.read(buffer);

                    if (bytesRead == -1) {
                        // 客户端关闭连接
                        socketChannel.close();
                        System.out.println("Connection closed by client: " + socketChannel.getRemoteAddress());
                    } else {
                        // 将缓冲区切换到读模式
                        buffer.flip();
                        byte[] data = new byte[buffer.remaining()];
                        buffer.get(data);
                        String message = new String(data).trim();
                        System.out.println("Received message from " + socketChannel.getRemoteAddress() + ": " + message);

                        // 回应客户端
                        String response = "Echo: " + message;
                        buffer.clear();
                        buffer.put(response.getBytes());
                        buffer.flip(); //切换回写状态
                        socketChannel.write(buffer);
                    }
                }

                // 移除已处理的键
                keys.remove();
            }
        }
    }
}