<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
    <scope>runtime</scope>
</dependency>

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=password
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue
    private Long id;
    private String name;
    private double balance;

    // Getters and Setters
}

import org.springframework.data.jpa.repository.JpaRepository;

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

import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    @Transactional
    public void transferMoney(Long fromUserId, Long toUserId, double amount) {
        User fromUser = userRepository.findById(fromUserId)
                .orElseThrow(() -> new RuntimeException("User not found"));
        User toUser = userRepository.findById(toUserId)
                .orElseThrow(() -> new RuntimeException("User not found"));

        fromUser.setBalance(fromUser.getBalance() - amount);
        toUser.setBalance(toUser.getBalance() + amount);

        userRepository.save(fromUser);
        userRepository.save(toUser);

        if (amount > 1000) {
            throw new RuntimeException("Transfer limit exceeded!");
        }
    }
}

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/users")
public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @PostMapping("/transfer")
    public void transferMoney(@RequestParam Long fromUserId, @RequestParam Long toUserId, @RequestParam double amount) {
        userService.transferMoney(fromUserId, toUserId, amount);
    }
}
Теперь, если перевести более 1000 единиц, метод выбросит исключение, а все изменения в базе данных будут откатаны.

public class Task091224_1 {
    public static void main(String[] args) {
        Random random = new Random(10);
        System.out.println(random.nextInt(100));
        
        random.setSeed(10);
        System.out.println(random.nextInt(100));
        
        Random anotherRandom = new Random(10);
        System.out.println(anotherRandom.nextInt(100));
        
        random.setSeed(20);
        System.out.println(random.nextInt(100));
    }
}

@Aspect
@Component
public class LoggingAspect {
    // Pointcut и Advice
}

@Pointcut("execution(* com.example.service.*.*(..))")
public void serviceLayer() {}

@Before("serviceLayer()")
public void logBefore() {
    System.out.println("Before method");
}

@After("serviceLayer()")
public void logAfter() {
    System.out.println("After method");
}

@AfterReturning(pointcut = "serviceLayer()", returning = "result")
public void logAfterReturning(Object result) {
    System.out.println("Method returned: " + result);
}

@AfterThrowing(pointcut = "serviceLayer()", throwing = "ex")
public void logAfterThrowing(Exception ex) {
    System.out.println("Exception thrown: " + ex.getMessage());
}

@Around("serviceLayer()")
public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
    System.out.println("Before method");
    Object result = joinPoint.proceed();
    System.out.println("After method");
    return result;
}

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/admin/**").hasRole("ADMIN")
                .requestMatchers("/user/**").hasAnyRole("USER", "ADMIN")
                .anyRequest().authenticated()
            )
            .formLogin()
            .and()
            .logout();
        return http.build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.provisioning.InMemoryUserDetailsManager;

@Configuration
public class InMemoryUserDetailsService {

    @Bean
    public UserDetailsService userDetailsService(PasswordEncoder passwordEncoder) {
        UserDetails user = User.withUsername("user")
                .password(passwordEncoder.encode("password"))
                .roles("USER")
                .build();

        UserDetails admin = User.withUsername("admin")
                .password(passwordEncoder.encode("admin"))
                .roles("ADMIN")
                .build();

        return new InMemoryUserDetailsManager(user, admin);
    }
}

import java.util.TreeSet;

public class Task101224_1 {
    public static void main(String[] args) {
        TreeSet<String> set = new TreeSet<>((s1, s2) -> s2.length() - s1.length());

        set.add("one");
        set.add("three");
        set.add("four");
        set.add("two");
        set.add("five");

        System.out.println(set);
    }
}

java -cp myapp.jar -Dconfig.file=app.properties com.example.Main

java -Xms512m -Xmx2g MyApp

java -XX:+UseG1GC -XX:+PrintGCDetails -XX:MaxHeapFreeRatio=70 MyApp

java -Xlog:gc* MyApp

http.authorizeHttpRequests(auth -> auth
    .requestMatchers("/admin/**").hasRole("ADMIN")
    .requestMatchers("/user/**").hasAnyRole("USER", "ADMIN")
    .anyRequest().authenticated()
);

http.csrf().disable();

@Bean
public PasswordEncoder passwordEncoder() {
    return new BCryptPasswordEncoder();
}

http.authorizeHttpRequests(auth -> auth
    .anyRequest().authenticated()
)
.formLogin(form -> form
    .successHandler((req, res, auth) -> System.out.println("Login success: " + auth.getName()))
    .failureHandler((req, res, ex) -> System.out.println("Login failure: " + ex.getMessage()))
);

String safeContent = HtmlUtils.htmlEscape(unsafeContent);

<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-api</artifactId>
    <version>0.11.5</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-impl</artifactId>
    <version>0.11.5</version>
</dependency>
<dependency>
    <groupId>io.jsonwebtoken</groupId>
    <artifactId>jjwt-jackson</artifactId>
    <version>0.11.5</version>
</dependency>

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;

public class JwtUtil {

    private static final String SECRET_KEY = "mySecretKey";

    public static String generateToken(String username) {
        return Jwts.builder()
                .setSubject(username)
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60)) // 1 час
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                .compact();
    }

    public static boolean validateToken(String token, String username) {
        String extractedUsername = Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token)
                .getBody()
                .getSubject();
        return username.equals(extractedUsername);
    }
}

@Configuration
public class JwtSecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .authorizeHttpRequests(auth -> auth
                .anyRequest().authenticated()
            )
            .addFilter(new JwtAuthenticationFilter())
            .sessionManagement().disable();
        return http.build();
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

implementation 'org.springframework.boot:spring-boot-starter-security'

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()  // Отключение CSRF для упрощения тестирования
            .authorizeHttpRequests((requests) -> requests
                .requestMatchers("/public/**").permitAll()  // Доступ для всех
                .anyRequest().authenticated()  // Остальные запросы требуют аутентификации
            )
            .formLogin((form) -> form
                .loginPage("/login")  // Кастомная страница логина
                .permitAll()
            )
            .logout((logout) -> logout.permitAll());

        return http.build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();  // Кодирование паролей
    }
}

import org.springframework.security.core.userdetails.User;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

import java.util.Collections;

@Service
public class CustomUserDetailsService implements UserDetailsService {

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        // Заглушка: обычно данные берутся из базы
        if ("admin".equals(username)) {
            return User.builder()
                .username("admin")
                .password("$2a$10$7b4/uWVqOKu8.cQeMEjCE.Oz7w9f5qL4uLcyuKkKJ7TzPByHOfy92")  // Закодированный "password"
                .roles("ADMIN")
                .build();
        } else {
            throw new UsernameNotFoundException("Пользователь не найден");
        }
    }
}

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

public class PasswordEncoderTest {
    public static void main(String[] args) {
        BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
        String rawPassword = "password";
        String encodedPassword = encoder.encode(rawPassword);
        System.out.println(encodedPassword);
    }
}

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class LoginController {

    @GetMapping("/login")
    public String login() {
        return "login";  // Вернет login.html
    }
}

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Login</title>
</head>
<body>
<h2>Login Page</h2>
<form th:action="@{/login}" method="post">
    <label for="username">Username:</label>
    <input type="text" id="username" name="username"/><br>
    <label for="password">Password:</label>
    <input type="password" id="password" name="password"/><br>
    <button type="submit">Login</button>
</form>
</body>
</html>

class Animal1112 {
    void sound() {
        System.out.println("Animal makes a sound");
    }
}

class Dog1112 extends Animal1112 {
    @Override
    void sound() {
        System.out.println("Dog barks");
    }

    void fetch() {
        System.out.println("Dog fetches a ball");
    }
}

class Cat1112 extends Animal1112 {
    @Override
    void sound() {
        System.out.println("Cat meows");
    }
}

public class Task111224_1 {
    public static void main(String[] args) {
        Animal1112 animal1 = new Dog1112();
        Animal1112 animal2 = new Cat1112();
        animal1.sound();
        animal2.sound();
        
        if (animal1 instanceof Dog1112) {
            ((Dog1112) animal1).fetch();
        }

        if (animal2 instanceof Dog1112) {
            ((Dog1112) animal2).fetch();
        } else {
            System.out.println("Not a Dog");
        }
    }
}

javac [опции] <файлы.java>

javac -d out src/com/example/MyClass.java

javac -cp libs/mylib.jar MyProgram.java

javac -source 11 MyProgram.java

javac -source 11 -target 8 MyProgram.java

javac -encoding UTF-8 MyProgram.java

java [опции] <имя_класса> [аргументы]

java -cp out:libs/mylib.jar com.example.MyClass

java -Dconfig.file=app.properties com.example.MyClass

java -Xmx2g -cp out:libs/mylib.jar com.example.MainClass arg1 arg2

jar cf myapp.jar -C out .

jar tf myapp.jar

jar cfe myapp.jar com.example.MainClass -C out .

javadoc -d docs -sourcepath src -subpackages com.example

javap -c com.example.MyClass

jdeps -summary myapp.jar

jdb -classpath out com.example.MainClass

jps -v

jstat -gc <pid>

jmap -heap <pid>

jstack <pid>

jcmd <pid> VM.uptime

javac -d out -sourcepath src src/com/example/MainClass.java

jar cfe myapp.jar com.example.MainClass -C out .

java -cp myapp.jar com.example.MainClass

jps
jstat -gc <pid>
jmap -heap <pid>

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    // Здесь будут методы настройки безопасности
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
public class SecurityConfig {
    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @PreAuthorize("hasRole('ADMIN')")
    public void adminOnlyMethod() {
        System.out.println("Только для администраторов");
    }

    @PreAuthorize("#username == authentication.principal.username")
    public void userSpecificMethod(String username) {
        System.out.println("Только для пользователя: " + username);
    }
}

import org.springframework.security.access.prepost.PostAuthorize;
import org.springframework.stereotype.Service;

@Service
public class ProductService {

    @PostAuthorize("returnObject.owner == authentication.principal.username")
    public Product getProductById(Long id) {
        // Имитируем возврат продукта
        return new Product(id, "username123");
    }
}

class Product {
    public Long id;
    public String owner;

    public Product(Long id, String owner) {
        this.id = id;
        this.owner = owner;
    }
}

import org.springframework.security.access.annotation.Secured;
import org.springframework.stereotype.Service;

@Service
public class ReportService {

    @Secured("ROLE_ADMIN")
    public void generateAdminReport() {
        System.out.println("Отчет для администратора");
    }

    @Secured({"ROLE_USER", "ROLE_MANAGER"})
    public void generateUserReport() {
        System.out.println("Отчет для пользователя или менеджера");
    }
}

@EnableGlobalMethodSecurity(securedEnabled = true)

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.security.test.context.support.WithMockUser;

@SpringBootTest
public class MyServiceTest {

    @Test
    @WithMockUser(username = "testUser", roles = {"USER"})
    public void testUserAccess() {
        // Тестовый метод, где выполняется проверка с фиктивным пользователем
        System.out.println("Тест с пользователем testUser");
    }
}

import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;

@Configuration
@EnableGlobalMethodSecurity(prePostEnabled = true, securedEnabled = true)
public class MethodSecurityConfig {
}

import jakarta.annotation.security.RolesAllowed;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    @RolesAllowed("ROLE_USER")
    public void userMethod() {
        System.out.println("Метод для пользователей");
    }
}

@EnableGlobalMethodSecurity(jsr250Enabled = true)

import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ApiController {

    @CrossOrigin(origins = "http://example.com")
    @GetMapping("/data")
    public String getData() {
        return "Data from server";
    }
}

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-security</artifactId>
</dependency>

implementation 'org.springframework.boot:spring-boot-starter-security'

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.SecurityFilterChain;

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()  // Отключение CSRF для упрощения
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/public/**").permitAll()  // Доступ к публичным ресурсам
                .requestMatchers("/admin/**").hasRole("ADMIN")  // Доступ только для ADMIN
                .anyRequest().authenticated()  // Остальные запросы требуют аутентификации
            )
            .formLogin(form -> form
                .loginPage("/login")  // Кастомная страница логина
                .permitAll()
            )
            .logout(logout -> logout
                .permitAll()
            );

        return http.build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();  // Для кодирования паролей
    }

    // Пример встроенной аутентификации
    @Bean
    public void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth
            .inMemoryAuthentication()
            .withUser("user")
            .password(passwordEncoder().encode("password"))
            .roles("USER")
            .and()
            .withUser("admin")
            .password(passwordEncoder().encode("admin"))
            .roles("ADMIN");
    }
}