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");
    }
}

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;

@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 io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.security.Keys;
import org.springframework.stereotype.Service;

import java.security.Key;
import java.util.Date;

@Service
public class JwtService {

    private final String secretKey = "mysecretkeymysecretkeymysecretkeymysecretkey"; // 256 бит

    public String generateToken(String username) {
        Key key = Keys.hmacShaKeyFor(secretKey.getBytes());
        return Jwts.builder()
                   .setSubject(username)
                   .setIssuedAt(new Date())
                   .setExpiration(new Date(System.currentTimeMillis() + 86400000))  // 1 день
                   .signWith(key, SignatureAlgorithm.HS256)
                   .compact();
    }
}

import io.jsonwebtoken.Claims;
import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.security.Keys;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.security.Key;
import java.util.Collections;

@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {

    private final String secretKey = "mysecretkeymysecretkeymysecretkeymysecretkey";

    @Override
    protected void doFilterInternal(HttpServletRequest request, 
                                    HttpServletResponse response, 
                                    FilterChain filterChain) 
                                    throws ServletException, IOException {
        String authHeader = request.getHeader("Authorization");

        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
            filterChain.doFilter(request, response);
            return;
        }

        String token = authHeader.substring(7);
        try {
            Key key = Keys.hmacShaKeyFor(secretKey.getBytes());
            Claims claims = Jwts.parserBuilder()
                                .setSigningKey(key)
                                .build()
                                .parseClaimsJws(token)
                                .getBody();

            String username = claims.getSubject();
            UsernamePasswordAuthenticationToken authentication =
                new UsernamePasswordAuthenticationToken(username, null, Collections.emptyList());
            SecurityContextHolder.getContext().setAuthentication(authentication);
        } catch (Exception e) {
            e.printStackTrace();
        }
          filterChain.doFilter(request, response);
    }
}

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

@Service
public class ReportService {

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

    @PreAuthorize("hasRole('USER')")
    public void generateUserReport() {
        System.out.println("Отчет для пользователя");
    }
}

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

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

class Parent1212 {
    int value = 10;

    void display() {
        System.out.println("Parent display");
    }
}

class Child1212 extends Parent1212 {
    int value = 20;

    @Override
    void display() {
        System.out.println("Child display");
    }

    void showValues() {
        System.out.println("Child value: " + value);
        System.out.println("Parent value: " + super.value);
    }
}

public class Task121224_1 {
    public static void main(String[] args) {
        Parent1212 obj1 = new Child1212();
        obj1.display();

        Child1212 obj2 = new Child1212();
        obj2.showValues();
    }
}

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.web.SecurityFilterChain;

@Configuration
public class SecurityConfig {

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

        return http.build();
    }
}

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Login</title>
</head>
<body>
<h2>Login</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>

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
        .csrf().disable()
        .authorizeHttpRequests(auth -> auth
            .anyRequest().authenticated()
        )
        .httpBasic();  // Включение HTTP Basic
    return http.build();
}

GET /api/resource HTTP/1.1
Authorization: Basic dXNlcm5hbWU6cGFzc3dvcmQ=

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import io.jsonwebtoken.security.Keys;

import java.security.Key;
import java.util.Date;

@Service
public class JwtService {
    private final String secretKey = "mysecretkeymysecretkeymysecretkeymysecretkey"; // 256 бит
    private final long expirationMs = 86400000; // 1 день

    public String generateToken(String username) {
        Key key = Keys.hmacShaKeyFor(secretKey.getBytes());
        return Jwts.builder()
                   .setSubject(username)
                   .setIssuedAt(new Date())
                   .setExpiration(new Date(System.currentTimeMillis() + expirationMs))
                   .signWith(key, SignatureAlgorithm.HS256)
                   .compact();
    }
}

import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.security.Keys;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.security.Key;

@Component
public class JwtAuthenticationFilter extends OncePerRequestFilter {

    private final String secretKey = "mysecretkeymysecretkeymysecretkeymysecretkey";

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain) throws ServletException, IOException {
        String authHeader = request.getHeader("Authorization");
        if (authHeader != null && authHeader.startsWith("Bearer ")) {
            String token = authHeader.substring(7);
            Key key = Keys.hmacShaKeyFor(secretKey.getBytes());
            String username = Jwts.parserBuilder()
                                  .setSigningKey(key)
                                  .build()
                                  .parseClaimsJws(token)
                                  .getBody()
                                  .getSubject();

            if (username != null) {
                SecurityContextHolder.getContext().setAuthentication(
                    new UsernamePasswordAuthenticationToken(username, null, null));
            }
        }
        filterChain.doFilter(request, response);
    }
}

@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
    http
        .csrf().disable()
        .authorizeHttpRequests(auth -> auth
            .anyRequest().authenticated()
        )
        .addFilterBefore(jwtAuthenticationFilter, UsernamePasswordAuthenticationFilter.class);
    return http.build();
}