Библиотека джависта | Java, Spring, Maven, Hibernate

lvl 3: A ------- H
lvl 2: A --- D -- H
lvl 1: A - B - D - F - H - J

@Component
public class EventPublisher {
    private final ApplicationEventPublisher publisher;

    public EventPublisher(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }

    public void publishEvent(String message) {
        System.out.println("Publishing event: " + message);
        publisher.publishEvent(new MyEvent(this, message));
    }
}

public class MyEvent {
    private final String message;

    public MyEvent(Object source, String message) {
        super();
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

@Component
public class EventListenerExample {

    @EventListener
    public void handleEvent(MyEvent event) {
        System.out.println("Event received: " + event.getMessage());
    }
}

public class Service {
    private final Repository repository;

    public Service(Repository repository) {
        this.repository = repository;
    }
}

public class Service {
    private Repository repository;

    public void setRepository(Repository repository) {
        this.repository = repository;
    }
}

@Component
public class Service {
    @Autowired
    private Repository repository;
}

String strongRef = new String("Strong Reference");

SoftReference<String> softRef = new SoftReference<>(new String("Soft Reference"));
String softObj = softRef.get();

WeakReference<String> weakRef = new WeakReference<>(new String("Weak Reference"));
String weakObj = weakRef.get();

PhantomReference<String> phantomRef = new PhantomReference<>(new String("Phantom Reference"), new ReferenceQueue<>());

interface A {
    void method();
}

interface B extends A {
    @Override
    default void method() {
        System.out.println("Method from B");
    }
}

interface C extends A {
    @Override
    default void method() {
        System.out.println("Method from C");
    }
}

class D implements B, C { }

public class Main {
    public static void main(String[] args) {
        D d = new D();
        d.method();  // Какая версия метода будет вызвана?
    }
}

class D implements B, C {
    @Override
    public void method() {
        B.super.method();
        // или можно использовать C.super.method(), если хотите вызвать метод из C
    }
}

public class VolatileExample {
    private static volatile boolean flag = false; 

    public static void main(String[] args) throws InterruptedException {
        Thread writer = new Thread(() -> {
            try {
                Thread.sleep(1000); // эмулируем задержку
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            flag = true; 
            System.out.println("Flag set to true");
        });

        Thread reader = new Thread(() -> {
            while (!flag) { 
            }
            System.out.println("Flag is now true");
        });

        writer.start();
        reader.start();

        writer.join();
        reader.join();
    }
}

query {
  user(id: "1") {
    name
    email
  }
}

{
  "data": {
    "user": {
      "name": "John Doe",
      "email": "[email protected]"
    }
  }
}

query {
  user(id: "1") {
    name
    posts {
      title
      comments {
        text
      }
    }
  }
}

{
  "data": {
    "user": {
      "name": "John Doe",
      "posts": [
        {
          "title": "My First Post",
          "comments": [
            { "text": "Great post!" },
            { "text": "Very helpful, thanks!" }
          ]
        }
      ]
    }
  }
}

type User {
  id: ID!
  name: String!
  email: String!
  posts: [Post]
}

type Post {
  id: ID!
  title: String!
  comments: [Comment]
}

type Comment {
  id: ID!
  text: String!
}

mutation {
  createUser(input: { name: "Jane", email: "[email protected]" }) {
    id
    name
    email
  }
}

{
  "data": {
    "createUser": {
      "id": "2",
      "name": "Jane",
      "email": "[email protected]"
    }
  }
}

subscription {
  messageAdded {
    id
    text
  }
}

public interface UserRepository extends JpaRepository<User, Long> {}

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public Page<User> getUsersByPage(int page, int size) {
        Pageable pageable = PageRequest.of(page, size, Sort.by("name").ascending());
        return userRepository.findAll(pageable);
    }
}

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/users")
    public Page<User> getUsers(
        @RequestParam(defaultValue = "0") int page,
        @RequestParam(defaultValue = "20") int size) {
        return userService.getUsersByPage(page, size);
    }
}