Add files via upload

Homework7/pom.xml

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>org.example</groupId>
+    <artifactId>Homework7</artifactId>
+    <version>1.0-SNAPSHOT</version>
+
+    <properties>
+        <maven.compiler.source>21</maven.compiler.source>
+        <maven.compiler.target>21</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+</project>

Homework7/src/main/java/Main.java

@@ -0,0 +1,39 @@
+import generator.RandomObjectGenerator;
+import model.MyClass;
+import model.MyRecord;
+import proxy.CacheProxy;
+import annotations.Cache;
+import proxy.FibCalculator;
+
+public class Main {
+    public static void main(String[] args) {
+        // генератор объектов
+        RandomObjectGenerator rog = new RandomObjectGenerator();
+
+        var myClass = rog.nextObject(MyClass.class, "create"); //через фабрику
+        System.out.println("MyClass (factory): " + myClass);
+
+
+        var myRecord = rog.nextObject(MyRecord.class); //через конструктор
+        System.out.println("MyRecord (random): " + myRecord);
+
+        // обычная реализация
+        FibCalculator original = new FibCalculator() {
+            @Override
+            @Cache(persist = true)
+            public long fib(int number) {
+                if (number <= 1) return number;
+                return fib(number - 1) + fib(number - 2);
+            }
+        };
+
+        // кэш-прокси
+        FibCalculator proxy = CacheProxy.create(original, FibCalculator.class);
+
+        // вызовы с кэшированием
+        System.out.println("fib(5): " + proxy.fib(5));
+        System.out.println("fib(6): " + proxy.fib(6));
+        System.out.println("fib(5) again (from cache): " + proxy.fib(5));
+    }
+
+}

Homework7/src/main/java/annotations/Cache.java

@@ -0,0 +1,9 @@
+package annotations;
+
+import java.lang.annotation.*;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface Cache {
+    boolean persist() default false;
+}

Homework7/src/main/java/annotations/Max.java

@@ -0,0 +1,9 @@
+package annotations;
+
+import java.lang.annotation.*;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface Max {
+    long value();
+}

Homework7/src/main/java/annotations/Min.java

@@ -0,0 +1,9 @@
+package annotations;
+
+import java.lang.annotation.*;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface Min {
+    long value();
+}

Homework7/src/main/java/annotations/NotNull.java

@@ -0,0 +1,7 @@
+package annotations;
+
+import java.lang.annotation.*;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface NotNull {}

Homework7/src/main/java/generator/RandomObjectGenerator.java

@@ -0,0 +1,55 @@
+package generator;
+
+import annotations.Max;
+import annotations.Min;
+
+import java.lang.reflect.*;
+import java.util.Random;
+
+public class RandomObjectGenerator {
+    private Random random = new Random();
+
+    public <T> T nextObject(Class<T> clazz) {
+        return nextObject(clazz, null);
+    }
+
+    public <T> T nextObject(Class<T> clazz, String factoryMethodName) {
+        try {
+            if (factoryMethodName != null) {
+                Method method = clazz.getMethod(factoryMethodName);
+                return clazz.cast(method.invoke(null));
+            }
+
+            Constructor<?> constructor = clazz.getDeclaredConstructors()[0];
+            constructor.setAccessible(true);
+
+            Parameter[] params = constructor.getParameters();
+            Object[] args = new Object[params.length];
+
+            for (int i = 0; i < params.length; i++) {
+                args[i] = generateValue(params[i]);
+            }
+
+            return clazz.cast(constructor.newInstance(args));
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private Object generateValue(Parameter parameter) {
+        Class<?> type = parameter.getType();
+        AnnotatedElement element = parameter;
+
+        if (type == int.class || type == Integer.class) {
+            long min = 0, max = 100;
+            if (element.isAnnotationPresent(Min.class))
+                min = element.getAnnotation(Min.class).value();
+            if (element.isAnnotationPresent(Max.class))
+                max = element.getAnnotation(Max.class).value();
+            return (int)(min + random.nextInt((int)(max - min + 1)));
+        } else if (type == String.class) {
+            return "str_" + random.nextInt(1000);
+        }
+        return null;
+    }
+}

Homework7/src/main/java/model/MyClass.java

@@ -0,0 +1,29 @@
+package model;
+
+import annotations.Min;
+import annotations.Max;
+import annotations.NotNull;
+
+public class MyClass {
+    @NotNull
+    @Min(10)
+    @Max(99)
+    private Integer age;
+
+    @NotNull
+    private String name;
+
+    public MyClass(Integer age, String name) {
+        this.age = age;
+        this.name = name;
+    }
+
+    public static MyClass create() {
+        return new MyClass(42, "FactoryCreated");
+    }
+
+    @Override
+    public String toString() {
+        return "MyClass{age=" + age + ", name='" + name + "'}";
+    }
+}

Homework7/src/main/java/model/MyRecord.java

@@ -0,0 +1,13 @@
+package model;
+
+import annotations.*;
+
+public record MyRecord(
+        @NotNull
+        @Min(10)
+        @Max(50)
+        Integer count,
+
+        @NotNull
+        String description
+) {}

Homework7/src/main/java/proxy/CacheProxy.java

@@ -0,0 +1,61 @@
+package proxy;
+
+import annotations.Cache;
+
+import java.io.*;
+import java.lang.reflect.*;
+import java.util.HashMap;
+import java.util.Map;
+
+public class CacheProxy {
+    @SuppressWarnings("unchecked")
+    public static <T> T create(T target, Class<?> interf) {
+        return (T) Proxy.newProxyInstance(
+                interf.getClassLoader(),
+                new Class<?>[]{interf},
+                new CacheHandler(target)
+        );
+    }
+
+    private static class CacheHandler implements InvocationHandler {
+        private final Object target;
+        private final Map<String, Object> cache = new HashMap<>();
+
+        public CacheHandler(Object target) {
+            this.target = target;
+        }
+
+        @Override
+        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+            if (!method.isAnnotationPresent(Cache.class))
+                return method.invoke(target, args);
+
+            String key = method.getName() + "#" + (args != null ? args[0] : "null");
+            Cache cacheAnn = method.getAnnotation(Cache.class);
+
+            if (cache.containsKey(key)) {
+                return cache.get(key);
+            }
+
+            File file = new File("cache_" + key + ".ser");
+            if (cacheAnn.persist() && file.exists()) {
+                try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file))) {
+                    Object result = ois.readObject();
+                    cache.put(key, result);
+                    return result;
+                }
+            }
+
+            Object result = method.invoke(target, args);
+            cache.put(key, result);
+
+            if (cacheAnn.persist()) {
+                try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file))) {
+                    oos.writeObject(result);
+                }
+            }
+
+            return result;
+        }
+    }
+}

Homework7/src/main/java/proxy/FibCalculator.java

@@ -0,0 +1,8 @@
+package proxy;
+
+import annotations.Cache;
+
+public interface FibCalculator {
+    @Cache(persist = true)
+    long fib(int number);
+}

Task1/Atomic_Counter.java

@@ -0,0 +1,14 @@
+package Task1;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class Atomic_Counter {
+    private final AtomicInteger count = new AtomicInteger(0);
+    public void increment() {
+        count.getAndIncrement();
+    }
+
+
+    public int getCount() {
+        return count.get();
+    }
+}

Task1/Client.java

@@ -0,0 +1,34 @@
+package Task1;
+import java.io.*;
+import java.net.ConnectException;
+import java.net.Socket;
+import java.util.Scanner;
+
+
+public class Client {
+    private static final String HOST = "localhost";
+    private static final int PORT = 55535;
+
+    public static void main(String[] args) {
+        try (Scanner scanner = new Scanner(System.in)) {
+            while (true) {
+                System.out.print("Ваня: ");
+                String input = scanner.nextLine().trim();
+                if (input.equalsIgnoreCase("exit")) break;
+
+                try (Socket socket = new Socket(HOST, PORT);
+                     ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream());
+                     ObjectInputStream in = new ObjectInputStream(socket.getInputStream())) {
+                    out.writeObject(input);
+                    out.flush();
+                    String response = (String) in.readObject();
+                    System.out.println("Сервер: " + response);
+                } catch (ConnectException e) {
+                    System.out.println("Сервер перегружен. Ожидайте...");
+                } catch (IOException | ClassNotFoundException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+}

Task1/ComputerClubAnalytics.java

@@ -0,0 +1,30 @@
+package Task1;
+import java.time.Duration;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.List;
+
+public class ComputerClubAnalytics {
+    public static String calculateAverageSessionTime(List<String> sessions) {
+        if (sessions == null || sessions.isEmpty()) {
+            return "0ч 0м";
+        }
+
+        Duration totalDuration = Duration.ZERO;
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd, HH:mm");
+
+        for (String session : sessions) {
+            String[] parts = session.split(" - ");
+            if (parts.length != 2) continue;
+
+            LocalDateTime start = LocalDateTime.parse(parts[0], formatter);
+            LocalDateTime end = LocalDateTime.parse(parts[1], formatter);
+            totalDuration = totalDuration.plus(Duration.between(start, end));
+        }
+
+        Duration averageDuration = totalDuration.dividedBy(sessions.size());
+        long hours = averageDuration.toHours();
+        long minutes = averageDuration.toMinutes() % 60;
+        return hours + "ч " + minutes + "м";
+    }
+}

Task1/ReetnrantLock_Counter.java

@@ -0,0 +1,19 @@
+package Task1;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class ReetnrantLock_Counter {
+    private int count = 0;
+    private final ReentrantLock lock = new ReentrantLock();
+    public void increment() {
+        lock.lock();
+        try {
+            count++;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    public int getCount() {
+        return count;
+    }
+}

Task1/Semaphore_Counter.java

@@ -0,0 +1,21 @@
+package Task1;
+import java.util.concurrent.Semaphore;
+
+public class Semaphore_Counter {
+    private int count = 0;
+    private final Semaphore semaphore = new Semaphore(1); // Используем стандартный Semaphore
+
+    public void increment() {
+        try {
+            semaphore.acquire(); // Метод acquire() из java.util.concurrent.Semaphore
+            count++;
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        } finally {
+            semaphore.release(); // Метод release() из java.util.concurrent.Semaphore
+        }
+    }
+
+    public int getCount() {
+        return count;
+    }