<!-- applicationContext.xml 片段：整合Hibernate會話工廠 -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    <property name="configLocation" value="classpath:hibernate.cfg.xml"/>
</bean>

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.3.21</version>
</dependency>

student-selection/
├── pom.xml
├── src/
│   ├── main/
│   │   ├── java/
│   │   ├── resources/
│   │   └── webapp/
│   │       └── WEB-INF/web.xml
└── target/student-selection.war

graph TD
    A[應用程序調用Session API] --> B{對象是否已存在緩存?}
    B -- 是 --> C[返回緩存對象]
    B -- 否 --> D[生成SQL語句]
    D --> E[通過JDBC連接執行SQL]
    E --> F[獲取ResultSet結果集]
    F --> G[使用反射構建Java對象]
    G --> H[放入一級緩存]
    H --> I[返回對象給應用]

@Entity
@Table(name = "t_student")
public class Student implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "stu_name", nullable = false, length = 50)
    private String name;

    @Column(name = "age")
    private Integer age;

    @Column(name = "gender")
    private String gender;

    // 必須提供無參構造函數
    public Student() {}

    // Getter and Setter methods...
}

@Entity
public class Grade {
    @Id
    private Long id;
    private String gradeName;

    @OneToMany(mappedBy = "grade", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
    private Set<Student> students = new HashSet<>();
}

@Entity
public class Student {
    @ManyToOne(fetch = FetchType.EAGER)
    @JoinColumn(name = "grade_id")
    private Grade grade;
}

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!-- 數據庫連接信息 -->
        <property name="connection.driver_class">com.mysql.cj.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/school_db?useSSL=false&serverTimezone=UTC</property>
        <property name="connection.username">root</property>
        <property name="connection.password">password</property>

        <!-- 方言設置 -->
        <property name="dialect">org.hibernate.dialect.MySQL8Dialect</property>

        <!-- 連接池配置（使用C3P0） -->
        <property name="c3p0.min_size">5</property>
        <property name="c3p0.max_size">20</property>
        <property name="c3p0.timeout">300</property>
        <property name="c3p0.max_statements">50</property>

        <!-- DDL生成策略 -->
        <property name="hbm2ddl.auto">update</property>

        <!-- 顯示SQL -->
        <property name="show_sql">true</property>
        <property name="format_sql">true</property>

        <!-- 啓用二級緩存 -->
        <property name="cache.use_second_level_cache">true</property>
        <property name="cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>

        <!-- 實體類註冊 -->
        <mapping class="com.example.entity.Student"/>
        <mapping class="com.example.entity.Course"/>
        <mapping class="com.example.entity.Grade"/>
    </session-factory>
</hibernate-configuration>

public class HibernateUtil {
    private static final SessionFactory sessionFactory = buildSessionFactory();

    private static SessionFactory buildSessionFactory() {
        try {
            return new Configuration().configure().buildSessionFactory();
        } catch (Throwable ex) {
            System.err.println("Initial SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }

    // 使用ThreadLocal綁定當前線程的Session
    private static final ThreadLocal<Session> sessionHolder = new ThreadLocal<>();

    public static Session getCurrentSession() {
        Session s = sessionHolder.get();
        if (s == null || !s.isOpen()) {
            s = sessionFactory.openSession();
            sessionHolder.set(s);
        }
        return s;
    }

    public static void closeCurrentSession() {
        Session s = sessionHolder.get();
        if (s != null) {
            s.close();
            sessionHolder.remove();
        }
    }
}

Query query = session.createQuery("FROM Student WHERE age > :age");
query.setParameter("age", 20);
query.setCacheable(true); // 啓用查詢緩存
List<Student> list = query.list();

Session session = HibernateUtil.getCurrentSession();
Transaction tx = null;

try {
    tx = session.beginTransaction();

    // CREATE
    Student student = new Student();
    student.setName("張三");
    student.setAge(20);
    session.save(student);

    // READ
    Student loaded = session.get(Student.class, 1L);

    // UPDATE
    loaded.setAge(21);
    session.update(loaded); // 或 merge()

    // DELETE
    session.delete(loaded);

    tx.commit();
} catch (Exception e) {
    if (tx != null) tx.rollback();
    e.printStackTrace();
}

String hql = "SELECT s FROM Student s WHERE s.age BETWEEN :minAge AND :maxAge";
Query query = session.createQuery(hql);
query.setParameter("minAge", 18);
query.setParameter("maxAge", 25);
List<Student> results = query.list();

Query query = session.createQuery("FROM Student");
query.setFirstResult((pageNo - 1) * pageSize);
query.setMaxResults(pageSize);
List<Student> pageData = query.list();

Number count = (Number) session.createQuery("SELECT COUNT(*) FROM Student").uniqueResult();
Double avgAge = (Double) session.createQuery("SELECT AVG(age) FROM Student").uniqueResult();

SQLQuery sqlQuery = session.createSQLQuery("SELECT * FROM t_student WHERE age > ?");
sqlQuery.addEntity(Student.class); // 映射結果到實體
sqlQuery.setParameter(0, 20);
List<Student> nativeResult = sqlQuery.list();

@Entity
@Table(name = "t_student")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE}, fetch = FetchType.LAZY)
    @JoinTable(
        name = "student_course",
        joinColumns = @JoinColumn(name = "student_id"),
        inverseJoinColumns = @JoinColumn(name = "course_id")
    )
    private Set<Course> courses = new HashSet<>();
}

@Entity
@Table(name = "t_course")
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToMany(mappedBy = "courses", fetch = FetchType.LAZY)
    private Set<Student> students = new HashSet<>();
}

student.getCourses().add(course);
session.save(student); // 自動保存中間表記錄

// 使用JOIN FETCH避免N+1問題
String hql = "SELECT DISTINCT s FROM Student s LEFT JOIN FETCH s.courses WHERE s.id = :id";

public class CourseService {
    private CourseDAO courseDAO = new CourseDAO(); // 硬編碼依賴
}

@Service
public class StudentService {
    @Autowired
    private StudentDAO studentDAO;

    public List<Student> getAllStudents() {
        return studentDAO.findAll();
    }
}

graph TD
    A[應用程序代碼] --> B[不再主動創建對象]
    C[Spring IoC Container] --> D[根據配置創建Bean]
    D --> E[解析依賴關係]
    E --> F[執行依賴注入]
    F --> G[嚮應用提供就緒的Bean實例]
    B --> G

@Service
public class StudentService {

    private final StudentDAO studentDAO;

    @Autowired
    public StudentService(StudentDAO studentDAO) {
        this.studentDAO = studentDAO;
    }

    // 方法省略...
}

@Test
public void testGetAllStudents() {
    StudentDAO mockDAO = Mockito.mock(StudentDAO.class);
    when(mockDAO.findAll()).thenReturn(Arrays.asList(new Student("張三")));

    StudentService service = new StudentService(mockDAO); // 直接注入mock對象

    assertEquals(1, service.getAllStudents().size());
}

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="studentDAO" class="com.example.dao.StudentDAOImpl"/>
    <bean id="studentService" class="com.example.service.StudentServiceImpl">
        <property name="studentDAO" ref="studentDAO"/>
    </bean>
</beans>

@Component("studentDAO")
public class StudentDAOImpl implements StudentDAO { ... }

@Service("studentService")
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentDAO studentDAO;
}

<context:component-scan base-package="com.example"/>

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig { }

@Component
@Scope("prototype") // 每次getBean都返回新實例
public class TemporaryReportGenerator { }

<bean id="reportGen" class="..." scope="prototype"/>

@PostConstruct
public void init() {
    System.out.println("Bean初始化完成，連接池已建立");
}

@PreDestroy
public void destroy() {
    System.out.println("Bean即將銷燬，釋放數據庫連接");
}

public class MyDAO implements InitializingBean, DisposableBean {

    @Override
    public void afterPropertiesSet() throws Exception {
        // 初始化邏輯
    }

    @Override
    public void destroy() throws Exception {
        // 銷燬前清理資源
    }
}

<bean id="myDao" class="com.example.MyDAO"
      init-method="customInit"
      destroy-method="customDestroy"/>

sequenceDiagram
    participant Container
    participant Bean
    Container->>Bean: 實例化
    Container->>Bean: 屬性賦值（DI）
    alt singleton
        Container->>Bean: 調用@PostConstruct / init-method
        Note right of Container: 加入單例緩存池
    end
    Bean-->>Container: 提供可用Bean
    ...
    Container->>Bean: 容器關閉時調用@PreDestroy / destroy-method

public interface EnrollmentService {
    boolean enrollStudent(Long studentId, Long courseId) throws BusinessException;
    List<Course> getEnrolledCourses(Long studentId);
}

@Service
@Transactional
public class EnrollmentServiceImpl implements EnrollmentService {

    @Autowired
    private EnrollmentDAO enrollmentDAO;

    @Autowired
    private CourseDAO courseDAO;

    @Override
    public boolean enrollStudent(Long studentId, Long courseId) {
        Course course = courseDAO.findById(courseId);
        if (course.getEnrolledCount() >= course.getCapacity()) {
            throw new BusinessException("課程人數已滿");
        }

        enrollmentDAO.save(new Enrollment(studentId, courseId));
        courseDAO.incrementEnrolledCount(courseId);

        return true;
    }
}

<tx:annotation-driven transaction-manager="transactionManager"/>

@EnableTransactionManagement
@Configuration
public class TransactionConfig {
    @Bean
    public PlatformTransactionManager transactionManager(SessionFactory sessionFactory) {
        return new HibernateTransactionManager(sessionFactory);
    }
}

classDiagram
    class TransactionProxy {
        +invoke(): Object
    }
    class EnrollmentService {
        +enrollStudent()
    }
    TransactionProxy --> "implements InvocationHandler" java.lang.reflect.InvocationHandler
    EnrollmentService <|-- TransactionProxy : JDK Proxy

@Transactional(
    propagation = Propagation.REQUIRED,
    isolation = Isolation.READ_COMMITTED,
    timeout = 30,
    readOnly = false,
    rollbackFor = {BusinessException.class}
)

@Service
public class BatchEnrollmentService {

    @Autowired
    private EnrollmentService enrollmentService;

    @Transactional
    public void batchEnroll(List<EnrollmentRequest> requests) {
        for (EnrollmentRequest req : requests) {
            try {
                enrollmentService.enrollStudent(req.getStuId(), req.getCourseId());
            } catch (BusinessException e) {
                log.warn("選課失敗：{}", e.getMessage());
                // 繼續處理下一個，不影響整體事務？
            }
        }
    }
}

@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public boolean enrollStudent(Long studentId, Long courseId) {
    // 單個選課獨立事務，失敗不影響其他
}

@Transactional(isolation = Isolation.SERIALIZABLE)
public boolean enrollStudent(...) {
    // 嚴格串行化執行，避免超賣
}

<bean id="sessionFactory" 
      class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="packagesToScan" value="com.example.entity"/>
    <property name="hibernateProperties">
        <props>
            <prop key="hibernate.dialect">org.hibernate.dialect.MySQL8Dialect</prop>
            <prop key="hibernate.hbm2ddl.auto">update</prop>
            <prop key="hibernate.show_sql">true</prop>
            <prop key="hibernate.format_sql">true</prop>
        </props>
    </property>
</bean>

@Repository
public class StudentDAOImpl implements StudentDAO {

    @Autowired
    private HibernateTemplate hibernateTemplate;

    @Override
    public List<Student> findAll() {
        return hibernateTemplate.loadAll(Student.class);
    }
}

@Autowired
private SessionFactory sessionFactory;

public List<Student> findAll() {
    return sessionFactory.getCurrentSession()
                        .createQuery("FROM Student", Student.class)
                        .list();
}

@Autowired
private PlatformTransactionManager transactionManager;

public void transferCredits() {
    TransactionDefinition def = new DefaultTransactionDefinition();
    TransactionStatus status = transactionManager.getTransaction(def);

    try {
        // 執行多個操作
        deductCredits(100);
        addCredits(100);
        transactionManager.commit(status);
    } catch (Exception e) {
        transactionManager.rollback(status);
        throw e;
    }
}

<filter>
    <filter-name>openSessionInViewFilter</filter-name>
    <filter-class>org.springframework.orm.hibernate5.support.OpenSessionInViewFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>openSessionInViewFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

sequenceDiagram
    participant Client
    participant Filter
    participant Controller
    participant View
    Client->>Filter: 請求到達
    Filter->>Filter: Open Session
    Filter->>Controller: 轉發請求
    Controller->>DB: 查詢（返回代理對象）
    Controller->>View: 返回ModelAndView
    View->>DB: 訪問lazy屬性（Session仍有效）
    View-->>Client: 渲染頁面
    Filter->>Filter: Close Session

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.cj.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/course_db"/>
    <property name="user" value="root"/>
    <property name="password" value="password"/>
    <property name="minPoolSize" value="5"/>
    <property name="maxPoolSize" value="20"/>
    <property name="maxIdleTime" value="3000"/>
</bean>

<bean id="dataSource" class="com.zaxxer.hikari.HikariDataSource">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="jdbcUrl" value="..."/>
    <property name="username" value="..."/>
    <property name="password" value="..."/>
    <property name="maximumPoolSize" value="15"/>
</bean>

<!-- 事務管理器 -->
<bean id="transactionManager" 
      class="org.springframework.orm.hibernate5.HibernateTransactionManager">
    <property name="sessionFactory" ref="sessionFactory"/>
</bean>

<!-- 開啓註解事務 -->
<tx:annotation-driven transaction-manager="transactionManager"/>

<!-- AOP配置 -->
<aop:config>
    <aop:pointcut id="serviceMethods" 
                  expression="execution(* com.example.service.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethods"/>
</aop:config>

<tx:advice id="txAdvice" transaction-manager="transactionManager">
    <tx:attributes>
        <tx:method name="get*" read-only="true"/>
        <tx:method name="find*" read-only="true"/>
        <tx:method name="*" propagation="REQUIRED"/>
    </tx:attributes>
</tx:advice>

<context:component-scan base-package="com.example">
    <context:exclude-filter type="annotation" 
                            expression="org.springframework.stereotype.Controller"/>
</context:component-scan>

public class LoginInterceptor extends AbstractInterceptor {
    @Override
    public String intercept(ActionInvocation invocation) throws Exception {
        Map<String, Object> session = invocation.getInvocationContext().getSession();
        if (session.get("user") == null) {
            return "login"; // 未登錄跳轉至登錄頁
        }
        return invocation.invoke(); // 放行請求
    }
}

<result name="success" type="redirect">listCourses.action</result>

graph TD
    A[HTTP Request] --> B{StrutsPrepareAndExecuteFilter}
    B --> C[Create ActionProxy]
    C --> D[Build Interceptor Stack]
    D --> E[Execute Pre-Action Interceptors]
    E --> F[Call Action Method]
    F --> G[Execute Post-Action Interceptors]
    G --> H{Return Result Code}
    H -- "success" --> I[Render JSP via Dispatcher]
    H -- "error" --> J[Show Error Page]
    H -- "input" --> K[Re-render Form with Errors]

public class StudentAction extends ActionSupport {
    private String name;
    private List<Course> courses;

    public String execute() {
        name = "張三";
        courses = courseService.findAll();
        return SUCCESS;
    }

    // getter/setter省略
}

<s:property value="name"/> <!-- 輸出"張三" -->
<s:iterator value="courses">
    <s:property value="courseName"/>
</s:iterator>

public class LoginAction extends ActionSupport implements SessionAware {
    private String username;
    private String password;
    private Map<String, Object> session;

    @Autowired
    private UserService userService;

    public String login() {
        try {
            User user = userService.authenticate(username, password);
            if (user != null) {
                session.put("user", user);
                return SUCCESS;
            } else {
                addFieldError("username", "用户名或密碼錯誤");
                return INPUT;
            }
        } catch (Exception e) {
            addActionError("系統異常，請稍後再試");
            return ERROR;
        }
    }

    // getter/setter 省略
    public void setSession(Map<String, Object> session) {
        this.session = session;
    }
}

<action name="login" class="com.example.LoginAction" method="login">
    <result name="success">/index.jsp</result>
    <result name="input">/login.jsp</result>
    <result name="error">/error.jsp</result>
</action>

<form action="saveStudent.action">
    <input type="text" name="name"/>
    <input type="text" name="age"/>
    <button>提交</button>
</form>

public class StudentAction extends ActionSupport {
    private String name;
    private int age;

    public String save() {
        Student s = new Student(name, age);
        studentService.save(s);
        return SUCCESS;
    }
    // getter/setter...
}

public class StudentAction extends ActionSupport implements ModelDriven<Student> {
    private Student student = new Student();

    public Student getModel() {
        return student;
    }

    public String save() {
        studentService.save(student); // 直接使用model
        return SUCCESS;
    }
}

<s:form action="saveStudent">
    <s:textfield name="name" label="姓名"/>
    <s:textfield name="age" label="年齡"/>
    <s:submit/>
</s:form>

@Intercepts({@InterceptorRef("defaultStack"), @InterceptorRef("login")})
public class AuthInterceptor extends AbstractInterceptor {

    public String intercept(ActionInvocation invocation) throws Exception {
        ActionContext ctx = invocation.getInvocationContext();
        Map<String, Object> session = ctx.getSession();
        String actionName = invocation.getProxy().getActionName();

        // 白名單放行
        if ("login".equals(actionName) || "doLogin".equals(actionName)) {
            return invocation.invoke();
        }

        User user = (User) session.get("user");
        if (user == null) {
            return "login";
        }

        // 記錄訪問日誌
        HttpServletRequest request = (HttpServletRequest) ctx.get(StrutsStatics.HTTP_REQUEST);
        System.out.println(user.getUsername() + " 訪問: " + request.getRequestURI());

        return invocation.invoke();
    }
}

<interceptors>
    <interceptor name="auth" class="com.example.AuthInterceptor"/>
    <interceptor-stack name="secureStack">
        <interceptor-ref name="defaultStack"/>
        <interceptor-ref name="auth"/>
    </interceptor-stack>
</interceptors>

<default-interceptor-ref name="secureStack"/>

<package name="student" namespace="/student" extends="struts-default">
    <action name="enroll" class="EnrollmentAction" method="enroll">
        <result name="success">/student/success.jsp</result>
    </action>
</package>

<package name="admin" namespace="/admin" extends="struts-default">
    <action name="addCourse" class="CourseAction" method="add">
        <result name="success">/admin/courseList.jsp</result>
    </action>
</package>

<result name="next" type="chain">confirmEnrollment</result>

<global-results>
    <result name="error">/common/error.jsp</result>
    <result name="login" type="redirect">/login.jsp</result>
</global-results>

<global-exception-mappings>
    <exception-mapping result="error" exception="java.lang.Exception"/>
</global-exception-mappings>

<s:form action="enroll">
    <s:textfield name="student.name" label="學生姓名"/>
    <s:select 
        name="course.id" 
        label="選擇課程"
        list="availableCourses" 
        listKey="id" 
        listValue="courseName + ' (' + credit + '學分)'"/>
    <s:submit value="選課"/>
</s:form>

<s:if test="hasRole('ADMIN')">
    <a href="editCourse.action?id=<s:property value='id'/>">編輯</a>
</s:if>

prompt.username=請輸入用户名
error.invalid.login=登錄失敗，請檢查賬號密碼

<s:text name="prompt.username"/>
<s:actionerror/>
<s:fielderror/>

// CourseDAO.java
public interface CourseDAO {
    List<Course> findAll();
    Course findById(Integer id);
    void update(Course course);
}

// EnrollmentService.java
public interface EnrollmentService {
    boolean enrollStudent(Student student, Course course) throws EnrollmentException;
}

<!-- applicationContext.xml -->
<context:component-scan base-package="com.student.system" />
<tx:annotation-driven transaction-manager="transactionManager"/>

@Service("enrollmentService")
@Transactional
public class EnrollmentServiceImpl implements EnrollmentService {

    @Autowired
    private EnrollmentDAO enrollmentDAO;

    @Autowired
    private CourseDAO courseDAO;

    @Override
    public boolean enrollStudent(Student student, Course course) {
        if (course.getEnrolled() >= course.getCapacity()) {
            throw new EnrollmentException("課程人數已達上限");
        }
        // 更新課程已選人數
        course.setEnrolled(course.getEnrolled() + 1);
        courseDAO.update(course);

        // 保存選課記錄
        Enrollment record = new Enrollment(student, course);
        enrollmentDAO.save(record);
        return true;
    }
}

@Controller
@Scope("prototype")
public class EnrollmentAction extends ActionSupport {

    @Autowired
    private EnrollmentService enrollmentService;

    private Integer courseId;
    private Student currentUser;

    public String execute() {
        try {
            enrollmentService.enrollStudent(currentUser, new Course(courseId));
            addActionMessage("選課成功！");
            return SUCCESS;
        } catch (EnrollmentException e) {
            addActionError(e.getMessage());
            return ERROR;
        }
    }
}

<global-exception-mappings>
    <exception-mapping exception="com.student.system.exception.EnrollmentException"
                       result="input"/>
    <exception-mapping exception="java.lang.Exception"
                       result="error"/>
</global-exception-mappings>

<global-results>
    <result name="error">/error.jsp</result>
    <result name="input">/enroll.jsp</result>
</global-results>

protected void handleException(Exception e, String defaultMsg) {
    log.error("業務執行異常", e);
    if (e instanceof EnrollmentException) {
        addActionError(e.getMessage());
    } else {
        addActionError(defaultMsg);
    }
}

public class CourseAction extends ActionSupport implements ModelDriven<Course> {
    private Course course = new Course();

    @Override
    public Course getModel() {
        return course;
    }
}

sequenceDiagram
    participant Browser
    participant Action
    participant Service
    participant DAO
    participant DB

    Browser->>Action: 提交選課請求
    Action->>Service: 調用enrollStudent()
    Service->>DAO: 查詢課程容量
    DAO->>DB: 執行SQL
    DB-->>DAO: 返回結果
    DAO-->>Service: Course對象
    Service->>DAO: 更新課程+插入記錄
    DAO->>DB: 批量操作（事務內）
    DB-->>DAO: 提交成功
    DAO-->>Service: 操作完成
    Service-->>Action: 返回true
    Action-->>Browser: 跳轉成功頁