Learning the SSM Framework

// Annotation way: @Lazy makes the Bean initialize only on first use
@Bean
@Lazy
public HeavyService heavyService() {
    return new HeavyService();
}

// XML way:
// <bean id="heavyService" class="..." lazy-init="true"/>

@Component
public class UserService {
    private final UserMapper userMapper;  // final ensures immutability

    // Spring 4.3+ can omit @Autowired for a single constructor
    public UserService(UserMapper userMapper) {
        this.userMapper = userMapper;
    }
}

<!-- XML constructor injection -->
<bean id="userService" class="com.example.UserService">
    <!-- reference type -->
    <constructor-arg name="userMapper" ref="userMapper"/>
    <!-- simple type -->
    <constructor-arg name="maxRetry" value="3"/>
</bean>

@Component
public class OrderService {
    private UserService userService;

    // The XML way requires a setter
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
}

<!-- XML setter injection -->
<bean id="orderService" class="com.example.OrderService">
    <property name="userService" ref="userService"/>
    <property name="timeout" value="3000"/>
</bean>

<bean id="dataConfig" class="com.example.DataConfig">
    <!-- List -->
    <property name="servers">
        <list>
            <value>192.168.1.1</value>
            <value>192.168.1.2</value>
        </list>
    </property>
    <!-- Map -->
    <property name="params">
        <map>
            <entry key="timeout" value="3000"/>
            <entry key="retry" value="3"/>
        </map>
    </property>
    <!-- Properties -->
    <property name="jdbcProps">
        <props>
            <prop key="url">jdbc:mysql://localhost:3306/db</prop>
        </props>
    </property>
</bean>

@Component
public class CacheService {

    @PostConstruct          // runs after Bean init completes (after property injection)
    public void init() {
        System.out.println("warming up the cache...");
        // connect to Redis, load hot data
    }

    @PreDestroy             // runs before Bean destruction (on container close)
    public void destroy() {
        System.out.println("cleaning up cache connections...");
        // release connection resources
    }
}

@Service
public class UserService {

    // @Autowired: inject by type
    // If there are multiple Beans of the same type, then match by field name
    @Autowired
    private UserMapper userMapper;

    // @Qualifier: specify which Bean to inject (required when there are multiple of the same type)
    @Autowired
    @Qualifier("mysqlUserMapper")
    private UserMapper specificMapper;

    // @Value: inject a simple value or a SpEL expression
    @Value("${app.timeout:5000}")  // read config, default 5000
    private int timeout;

    @Value("#{systemProperties['os.name']}")  // SpEL expression
    private String osName;
}

// 1. Add @PropertySource on the config class
@Configuration
@ComponentScan("com.example")
@PropertySource("classpath:application.properties")  // no wildcards!
// Multiple-file form:
// @PropertySource({"classpath:db.properties", "classpath:app.properties"})
public class SpringConfig { }

// 2. Only then can you use @Value in a Bean
@Value("${jdbc.url}")
private String jdbcUrl;

// Data source config class
@Configuration
public class JdbcConfig {

    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.username}")
    private String username;

    @Value("${jdbc.password}")
    private String password;

    // Reference-type injection: declare it on the method parameter, Spring injects it automatically
    @Bean
    public DataSource dataSource() {
        DruidDataSource ds = new DruidDataSource();
        ds.setUrl(url);
        ds.setUsername(username);
        ds.setPassword(password);
        return ds;
    }
}

// Main config class: aggregate with @Import, don't scan config classes via @ComponentScan
@Configuration
@ComponentScan("com.example")
@PropertySource("classpath:application.properties")
@Import({JdbcConfig.class, MyBatisConfig.class})  // recommended
public class SpringConfig { }

@Configuration
public class MyBatisConfig {

    // DataSource is auto-injected from the Spring container (method-parameter injection)
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) {
        SqlSessionFactoryBean factory = new SqlSessionFactoryBean();
        factory.setDataSource(dataSource);
        // Set MyBatis global config (optional)
        // factory.setConfigLocation(new ClassPathResource("mybatis-config.xml"));
        // Enable camelCase mapping
        org.apache.ibatis.session.Configuration config =
            new org.apache.ibatis.session.Configuration();
        config.setMapUnderscoreToCamelCase(true);
        factory.setConfiguration(config);
        return factory;
    }

    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer() {
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        // Scan the package containing Mapper interfaces, auto-generate proxies registered into the container
        msc.setBasePackage("com.example.mapper");
        return msc;
    }
}

// JUnit 4 style (legacy projects)
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class UserServiceTest {
    @Autowired
    private UserService userService;

    @Test
    public void testFind() { /* ... */ }
}

// JUnit 5 style (recommended, Spring Boot default)
@SpringJUnitConfig(classes = SpringConfig.class)
// equivalent to @ExtendWith(SpringExtension.class) + @ContextConfiguration
public class UserServiceTest {
    @Autowired
    private UserService userService;

    @Test
    void testFind() { /* ... */ }
}

// Syntax: execution(modifier? return-type package.class?.method(params) exceptions?)
// ? means optional

// Exact match
@Pointcut("execution(void com.example.service.UserService.save())")

// Match all methods of a class
@Pointcut("execution(* com.example.service.UserService.*(..))")
//                   ^any return  ^any method name  ^any params

// Match all methods of all classes in a package (not sub-packages)
@Pointcut("execution(* com.example.service.*.*(..))")

// Match all methods of all classes in a package and its sub-packages
@Pointcut("execution(* com.example.service..*.*(..))")
//                                           ^^ the double dot means include sub-packages

// A common real-project form: intercept all methods of the service layer
@Pointcut("execution(* com.example.service.impl.*.*(..))")

@Aspect
@Component
public class LogAspect {

    // Define a reusable pointcut
    @Pointcut("execution(* com.example.service..*.*(..))")
    public void serviceMethods() {}

    // Before advice: before the method runs
    @Before("serviceMethods()")
    public void before(JoinPoint jp) {
        System.out.println("method starting: " + jp.getSignature().getName());
        Object[] args = jp.getArgs();  // get the arguments
        System.out.println("args: " + Arrays.toString(args));
    }

    // After advice: after the method runs (whether or not it threw)
    @After("serviceMethods()")
    public void after(JoinPoint jp) {
        System.out.println("method ended: " + jp.getSignature().getName());
    }

    // AfterReturning advice: after normal return (not run on exception)
    @AfterReturning(value = "serviceMethods()", returning = "result")
    public void afterReturning(JoinPoint jp, Object result) {
        System.out.println("return value: " + result);
    }

    // AfterThrowing advice: after the method throws
    @AfterThrowing(value = "serviceMethods()", throwing = "ex")
    public void afterThrowing(JoinPoint jp, Exception ex) {
        System.out.println("exception: " + ex.getMessage());
        // Can send an alert here
    }

    // Around advice: the most powerful, can control whether the original method runs
    @Around("serviceMethods()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        // Get the method signature
        String methodName = pjp.getSignature().getName();
        Object[] args = pjp.getArgs();

        long start = System.currentTimeMillis();
        try {
            // Execute the original method (if you don't call it, the original method won't run)
            Object result = pjp.proceed();
            long cost = System.currentTimeMillis() - start;
            System.out.printf("[%s] took: %dms%n", methodName, cost);
            return result;
        } catch (Throwable e) {
            System.out.println("[" + methodName + "] exception: " + e.getMessage());
            throw e;  // must rethrow, or the exception gets swallowed
        }
    }
}

// Spring AOP's two proxy approaches:
// 1. JDK dynamic proxy: the target class implements an interface → proxy the interface
// 2. CGLIB proxy: the target class has no interface → generate a subclass by inheriting the target class

// Spring Boot uses CGLIB by default (whether or not there's an interface)
// Reason: avoids the "must program to an interface" constraint, more flexible to use

// CGLIB note:
// final classes/methods can't be proxied by CGLIB (can't be inherited/overridden)

// 1. Configure the transaction manager (use DataSourceTransactionManager when integrating MyBatis)
@Bean
public PlatformTransactionManager transactionManager(DataSource dataSource) {
    return new DataSourceTransactionManager(dataSource);
}

// 2. Enable transaction-annotation support
@Configuration
@EnableTransactionManagement  // enable @Transactional support
public class SpringConfig { }

// 3. Use it on a Service method
@Service
public class AccountService {

    // On the interface: lower coupling (recommended), implementations inherit it automatically
    // On the implementation class: more explicit, but couples the interface to the implementation
    @Transactional
    public void transfer(Long fromId, Long toId, BigDecimal amount) {
        accountMapper.deduct(fromId, amount);
        // If an exception is thrown here, the deduct above rolls back automatically
        accountMapper.add(toId, amount);
    }
}

@Service
public class OrderService {

    @Autowired
    private LogService logService;

    @Transactional
    public void createOrder(Order order) {
        orderMapper.insert(order);

        // Even if createOrder ultimately rolls back, the log is still written successfully
        logService.writeLog("created order: " + order.getId());

        // Simulate an exception to trigger rollback
        if (order.getAmount().compareTo(BigDecimal.ZERO) < 0) {
            throw new BusinessException("amount can't be negative");
        }
    }
}

@Service
public class LogService {

    // REQUIRES_NEW: open an independent transaction, unaffected by the outer one
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void writeLog(String message) {
        logMapper.insert(new Log(message, LocalDateTime.now()));
    }
}

// ❌ Wrong: the method isn't public, @Transactional doesn't take effect
@Transactional
private void internalTransfer() { }

// ❌ Wrong: same-class internal call bypasses the proxy, transaction doesn't take effect
@Service
public class UserService {
    public void doA() {
        this.doB();  // direct call, doesn't go through the AOP proxy!
    }

    @Transactional
    public void doB() { }
}

// ✅ Correct: inject the class's own proxy (or use AopContext.currentProxy())
@Service
public class UserService {
    @Autowired
    private UserService self;  // inject the proxy object

    public void doA() {
        self.doB();  // call through the proxy, transaction takes effect
    }
}

// ❌ Wrong: the exception is caught, Spring doesn't know to roll back
@Transactional
public void save(User user) {
    try {
        userMapper.insert(user);
    } catch (Exception e) {
        log.error("save failed", e);
        // no rethrow, the transaction won't roll back!
    }
}

// ✅ Correct: or mark for rollback manually
@Transactional
public void save(User user) {
    try {
        userMapper.insert(user);
    } catch (Exception e) {
        log.error("save failed", e);
        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
    }
}

@RestController  // = @Controller + @ResponseBody
@RequestMapping("/users")
public class UserController {

    // 1. Ordinary parameters: auto-bind by matching names
    @GetMapping
    public List<User> list(String name, Integer age) { }

    // 2. POJO parameter: auto-bind same-named fields
    @PostMapping
    public User create(UserCreateDTO dto) { }

    // 3. Array parameter: multiple values with the same name
    @GetMapping("/batch")
    public List<User> batch(String[] ids) { }

    // 4. Collection parameter: must add @RequestParam
    @GetMapping("/list")
    public List<User> list(@RequestParam List<String> ids) { }

    // 5. JSON parameter: must add @RequestBody, needs jackson-databind
    @PostMapping("/json")
    public Result createFromJson(@RequestBody UserCreateDTO dto) { }

    // 6. Path parameter
    @GetMapping("/{id}")
    public User getById(@PathVariable Long id) { }

    // 7. Date parameter: specify the format
    @GetMapping("/born")
    public List<User> byBirth(
        @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate birthDate) { }
}

// Unified response body
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Result<T> {
    private Integer code;     // business status code
    private String message;
    private T data;

    public static <T> Result<T> success(T data) {
        return new Result<>(200, "success", data);
    }

    public static <T> Result<T> fail(Integer code, String message) {
        return new Result<>(code, message, null);
    }
}

// Controller usage
@GetMapping("/{id}")
public Result<User> getById(@PathVariable Long id) {
    User user = userService.getById(id);
    return Result.success(user);
}

// Custom business exception
public class BusinessException extends RuntimeException {
    private final Integer code;

    public BusinessException(Integer code, String message) {
        super(message);
        this.code = code;
    }
}

// Custom system exception
public class SystemException extends RuntimeException {
    private final Integer code;
    public SystemException(Integer code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
    }
}

// Global exception handler
@RestControllerAdvice  // = @ControllerAdvice + @ResponseBody
public class GlobalExceptionHandler {

    // Handle business exceptions (expected, e.g. validation failures, business-rule conflicts)
    @ExceptionHandler(BusinessException.class)
    public Result<Void> handleBusiness(BusinessException e) {
        log.warn("business exception: {}", e.getMessage());
        return Result.fail(e.getCode(), e.getMessage());
    }

    // Handle system exceptions (unexpected, e.g. DB connection failures)
    @ExceptionHandler(SystemException.class)
    public Result<Void> handleSystem(SystemException e) {
        log.error("system exception: ", e);
        return Result.fail(500, "system busy, please retry later");
    }

    // Handle all uncaught exceptions (fallback)
    @ExceptionHandler(Exception.class)
    public Result<Void> handleAll(Exception e) {
        log.error("unknown exception: ", e);
        return Result.fail(500, "internal server error");
    }
}

// 1. Implement the HandlerInterceptor interface
@Component
public class LoginInterceptor implements HandlerInterceptor {

    @Autowired
    private JwtUtil jwtUtil;

    // Before request handling: returning false interrupts the request chain
    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {
        String token = request.getHeader("Authorization");
        if (token == null || !jwtUtil.verify(token)) {
            response.setStatus(401);
            response.getWriter().write("{\"code\":401,\"message\":\"please log in first\"}");
            return false;  // interrupt, don't continue
        }
        return true;  // let it through
    }

    // After request handling (after the Controller runs): can modify the ModelAndView
    @Override
    public void postHandle(HttpServletRequest req, HttpServletResponse res,
                           Object handler, ModelAndView mv) { }

    // After view rendering completes: for resource cleanup
    @Override
    public void afterCompletion(HttpServletRequest req, HttpServletResponse res,
                                Object handler, Exception ex) {
        // clean up ThreadLocal and other resources
    }
}

// 2. Register the interceptor
@Configuration
public class WebConfig extends WebMvcConfigurationSupport {

    @Autowired
    private LoginInterceptor loginInterceptor;

    @Override
    protected void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(loginInterceptor)
                .addPathPatterns("/**")           // intercept everything
                .excludePathPatterns(             // let through
                    "/users/login",
                    "/users/register",
                    "/swagger-ui/**"
                );
    }
}

<!-- Method 1: exclude a transitive dependency -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.3.20</version>
    <exclusions>
        <exclusion>
            <!-- Exclude the old commons-logging brought in by spring-core -->
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
        </exclusion>
    </exclusions>
</dependency>

<!-- Method 2: lock the version uniformly in the parent pom (dependencyManagement) -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.15</version>
        </dependency>
    </dependencies>
</dependencyManagement>

<!-- Parent project pom.xml (packaging must be pom) -->
<groupId>com.example</groupId>
<artifactId>parent</artifactId>
<version>1.0.0</version>
<packaging>pom</packaging>

<!-- Aggregation: the parent manages multiple modules (mvn package builds all modules in order) -->
<modules>
    <module>common</module>
    <module>service</module>
    <module>web</module>
</modules>

<!-- Dependency management: declare versions so child modules don't need to write them -->
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.7.0</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<!-- Child project pom.xml -->
<parent>
    <groupId>com.example</groupId>
    <artifactId>parent</artifactId>
    <version>1.0.0</version>
    <relativePath>../parent/pom.xml</relativePath>
</parent>

<artifactId>service</artifactId>
<!-- No need to write groupId and version, inherited from the parent -->

<dependencies>
    <!-- No version needed, managed by the parent's dependencyManagement -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

<!-- Define profiles in pom.xml -->
<profiles>
    <profile>
        <id>dev</id>
        <properties>
            <profile.active>dev</profile.active>
        </properties>
        <activation>
            <activeByDefault>true</activeByDefault>  <!-- active by default -->
        </activation>
    </profile>
    <profile>
        <id>prod</id>
        <properties>
            <profile.active>prod</profile.active>
        </properties>
    </profile>
</profiles>

# Specify the environment at build time
mvn package -P prod

# Skip tests
mvn package -DskipTests
# or
mvn package -Dmaven.test.skip=true  # even skips compiling the test code

// SpringConfig: scan only non-Controller components
@Configuration
@ComponentScan(value = "com.example",
    excludeFilters = @ComponentScan.Filter(
        type = FilterType.ANNOTATION,
        classes = Controller.class
    )
)
public class SpringConfig { }

// SpringMvcConfig: scan only Controllers
@Configuration
@ComponentScan("com.example.controller")
@EnableWebMvc
public class SpringMvcConfig { }

// The essence of @EnableWebMvc:
// @Import(DelegatingWebMvcConfiguration.class)
// It registers a complete set of MVC components into the container:

// Enable @RequestMapping route mapping
// Enable @Controller / @ResponseBody annotation handling
// Enable automatic JSON conversion (needs jackson-databind on the classpath)
// Register parameter-binding converters (@DateTimeFormat, etc.)
// Register DispatcherServlet-related components (HandlerAdapter, etc.)
// Enable static-resource handling, view resolution, etc.

// Way 1: implement WebMvcConfigurer (recommended, non-intrusive)
@Configuration
@EnableWebMvc
public class WebConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) { }

    @Override
    public void addCorsMappings(CorsRegistry registry) { }
    // Override only the methods you need; the rest keep @EnableWebMvc's defaults
}

// Way 2: extend WebMvcConfigurationSupport (intrusive, use with caution)
@Configuration
public class WebConfig extends WebMvcConfigurationSupport {
    // After extending this class, @EnableWebMvc's auto-configuration is disabled!
    // You must manually configure all needed MVC components, or many defaults fail
}

// default (package access, no modifier)
class DefaultClass {
    void defaultMethod() {}  // only classes in the same package can access
}

// protected
class Base {
    protected void protectedMethod() {}
}

// The key difference: subclasses in a different package
// ✅ protected can be inherited across packages
package com.other;
import com.example.Base;
class Sub extends Base {
    void test() {
        protectedMethod();  // ✅ can access
    }
}

// ❌ default can't be inherited across packages
package com.other;
import com.example.DefaultClass;
class Sub extends DefaultClass {
    void test() {
        defaultMethod();  // ❌ compile error: not visible
    }
}

// Remember:
// Same package: both default and protected are accessible
// Subclass in a different package: only protected is accessible (default isn't)
// Non-subclass in a different package: neither default nor protected is accessible

// Direct assignment: hardcoded, can't be configured externally
private int timeout = 5000;

// @Value: read from config files/environment variables at runtime, supports externalized config
@Value("${app.timeout:5000}")  // default 5000
private int timeout;

// Other uses of @Value:
@Value("${server.port}")          // read from application.properties
@Value("#{T(Math).PI}")           // SpEL expression
@Value("#{systemProperties['java.home']}")  // system property
@Value("${MY_ENV_VAR}")           // environment variable