Session 3

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.ignou.lab</groupId>
  <artifactId>student-admission</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
  <name>student-admission</name>
  <description>Lab project for Student Admission using Spring MVC (classic, Tomcat 10.1)</description>

  <properties>
    <maven.compiler.release>17</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <spring.version>6.1.14</spring.version>
  </properties>

  <dependencies>
    <!-- Spring MVC: DispatcherServlet, controllers, form tags -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>${spring.version}</version>
    </dependency>
    <!-- Servlet API: Tomcat 10.1 provides it at run time -->
    <dependency>
      <groupId>jakarta.servlet</groupId>
      <artifactId>jakarta.servlet-api</artifactId>
      <version>6.0.0</version>
      <scope>provided</scope>
    </dependency>
    <!-- JSTL 3.0 (Jakarta namespace) for c:forEach and c:out in JSPs -->
    <dependency>
      <groupId>jakarta.servlet.jsp.jstl</groupId>
      <artifactId>jakarta.servlet.jsp.jstl-api</artifactId>
      <version>3.0.0</version>
    </dependency>
    <dependency>
      <groupId>org.glassfish.web</groupId>
      <artifactId>jakarta.servlet.jsp.jstl</artifactId>
      <version>3.0.1</version>
    </dependency>
  </dependencies>

  <build>
    <finalName>student-admission</finalName>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.13.0</version>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-war-plugin</artifactId>
        <version>3.4.0</version>
        <configuration>
          <!-- no web.xml: WebAppInitializer registers the DispatcherServlet -->
          <failOnMissingWebXml>false</failOnMissingWebXml>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

package com.ignou.lab.admission;

import jakarta.servlet.Filter;
import org.springframework.web.filter.CharacterEncodingFilter;
import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

/**
 * Replaces web.xml. Tomcat finds this class through the Servlet 3+
 * ServletContainerInitializer mechanism and it registers the DispatcherServlet.
 */
public class WebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {

    @Override
    protected Class<?>[] getRootConfigClasses() {
        return null; // one context is enough for this lab
    }

    @Override
    protected Class<?>[] getServletConfigClasses() {
        return new Class<?>[] { WebConfig.class };
    }

    @Override
    protected String[] getServletMappings() {
        return new String[] { "/" };
    }

    @Override
    protected Filter[] getServletFilters() {
        return new Filter[] { new CharacterEncodingFilter("UTF-8", true) };
    }
}

package com.ignou.lab.admission;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.EnableWebMvc;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.view.InternalResourceViewResolver;

@Configuration
@EnableWebMvc
@ComponentScan("com.ignou.lab.admission")
public class WebConfig implements WebMvcConfigurer {

    /** "home" returned from a controller becomes /WEB-INF/views/home.jsp */
    @Bean
    public InternalResourceViewResolver viewResolver() {
        return new InternalResourceViewResolver("/WEB-INF/views/", ".jsp");
    }
}

package com.ignou.lab.admission.web;

import java.time.LocalDateTime;
import org.springframework.core.SpringVersion;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HomeController {

    @GetMapping("/")
    public String home(Model model) {
        model.addAttribute("springVersion", SpringVersion.getVersion());
        model.addAttribute("now", LocalDateTime.now());
        return "home";
    }
}

<%@ page contentType="text/html;charset=UTF-8" %>
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Student Admission</title>
</head>
<body>
  <h1>Welcome to the Lab Project for Student Admission using Spring MVC</h1>
  <p>Spring Framework version: ${springVersion}</p>
  <p>Server time: ${now}</p>
  <p><a href="${pageContext.request.contextPath}/students">Students in the IGNOU database</a></p>
</body>
</html>

<!-- Q15: add inside <dependencies> of pom.xml, then Maven > Update Project -->
<!-- Spring's JPA glue: LocalContainerEntityManagerFactoryBean, JpaTransactionManager -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-orm</artifactId>
  <version>${spring.version}</version>
</dependency>
<!-- Hibernate 6 = JPA 3.1 provider; pulls in jakarta.persistence-api -->
<dependency>
  <groupId>org.hibernate.orm</groupId>
  <artifactId>hibernate-core</artifactId>
  <version>6.6.3.Final</version>
</dependency>
<!-- MySQL Connector/J 8 (driver class com.mysql.cj.jdbc.Driver) -->
<dependency>
  <groupId>com.mysql</groupId>
  <artifactId>mysql-connector-j</artifactId>
  <version>8.4.0</version>
</dependency>

-- Student table of the IGNOU database created in Session 1, Question 5.
-- If your Session 1 table used other column names, change the @Column names
-- in Student.java; hibernate.hbm2ddl.auto=update adds any column that is missing.
CREATE DATABASE IF NOT EXISTS ignou;
USE ignou;

CREATE TABLE IF NOT EXISTS student (
  id              BIGINT AUTO_INCREMENT PRIMARY KEY,
  enrolment_no    VARCHAR(12) UNIQUE,
  name            VARCHAR(80)  NOT NULL,
  email           VARCHAR(120) NOT NULL,
  mobile          VARCHAR(10)  NOT NULL,
  dob             DATE         NOT NULL,
  address         VARCHAR(255),
  programme       VARCHAR(10)  NOT NULL,
  courses         VARCHAR(255),
  hostel_required BIT(1)       NOT NULL DEFAULT 0
);

INSERT INTO student (enrolment_no, name, email, mobile, dob, address, programme, courses, hostel_required) VALUES
  ('2201234567', 'Asha Verma',  'asha@example.com',  '9876543210', '2003-04-12', 'Sector 4, Rohini, Delhi', 'MCA', 'MCS-218,MCS-220', 1),
  ('2201234568', 'Rahul Singh', 'rahul@example.com', '9123456780', '2002-11-30', 'Boring Road, Patna',      'MCA', 'MCS-219',         0);

# src/main/resources/db.properties
db.driver=com.mysql.cj.jdbc.Driver
db.url=jdbc:mysql://localhost:3306/ignou
db.username=root
db.password=Ignou@1234

package com.ignou.lab.admission;

import java.util.Properties;
import javax.sql.DataSource;
import jakarta.persistence.EntityManagerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

/**
 * Hibernate 6 as the JPA provider, wired by Spring. Picked up by the
 * component scan in WebConfig, so nothing else needs to change.
 */
@Configuration
@EnableTransactionManagement
@PropertySource("classpath:db.properties")
public class JpaConfig {

    @Bean
    public DataSource dataSource(Environment env) {
        // ponytail: no connection pool; switch to HikariDataSource when more than one user hits the app
        DriverManagerDataSource ds = new DriverManagerDataSource();
        ds.setDriverClassName(env.getRequiredProperty("db.driver"));
        ds.setUrl(env.getRequiredProperty("db.url"));
        ds.setUsername(env.getRequiredProperty("db.username"));
        ds.setPassword(env.getRequiredProperty("db.password"));
        return ds;
    }

    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory(DataSource dataSource) {
        LocalContainerEntityManagerFactoryBean emf = new LocalContainerEntityManagerFactoryBean();
        emf.setDataSource(dataSource);
        emf.setPackagesToScan("com.ignou.lab.admission.entity");
        emf.setJpaVendorAdapter(new HibernateJpaVendorAdapter());
        Properties props = new Properties();
        props.put("hibernate.hbm2ddl.auto", "update"); // adds missing columns, never drops
        props.put("hibernate.show_sql", "true");
        props.put("hibernate.format_sql", "true");
        emf.setJpaProperties(props);
        return emf;
    }

    @Bean
    public PlatformTransactionManager transactionManager(EntityManagerFactory emf) {
        return new JpaTransactionManager(emf);
    }
}

package com.ignou.lab.admission.entity;

import java.time.LocalDate;
import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;

/** Maps the student table of the IGNOU database from Session 1. */
@Entity
@Table(name = "student")
public class Student {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(name = "enrolment_no", length = 12, unique = true)
    private String enrolmentNo;

    @Column(nullable = false, length = 80)
    private String name;

    @Column(nullable = false, length = 120)
    private String email;

    @Column(nullable = false, length = 10)
    private String mobile;

    @Column(nullable = false)
    private LocalDate dob;

    @Column(length = 255)
    private String address;

    @Column(nullable = false, length = 10)
    private String programme;

    /** comma-separated course codes, as stored by the Session 1 servlet */
    @Column(length = 255)
    private String courses;

    @Column(name = "hostel_required")
    private Boolean hostelRequired;

    public Long getId() { return id; }
    public void setId(Long id) { this.id = id; }
    public String getEnrolmentNo() { return enrolmentNo; }
    public void setEnrolmentNo(String enrolmentNo) { this.enrolmentNo = enrolmentNo; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    public String getMobile() { return mobile; }
    public void setMobile(String mobile) { this.mobile = mobile; }
    public LocalDate getDob() { return dob; }
    public void setDob(LocalDate dob) { this.dob = dob; }
    public String getAddress() { return address; }
    public void setAddress(String address) { this.address = address; }
    public String getProgramme() { return programme; }
    public void setProgramme(String programme) { this.programme = programme; }
    public String getCourses() { return courses; }
    public void setCourses(String courses) { this.courses = courses; }
    public Boolean getHostelRequired() { return hostelRequired; }
    public void setHostelRequired(Boolean hostelRequired) { this.hostelRequired = hostelRequired; }

    @Override
    public String toString() {
        return "Student[id=" + id + ", enrolmentNo=" + enrolmentNo + ", name=" + name
                + ", programme=" + programme + ", courses=" + courses + "]";
    }
}

package com.ignou.lab.admission.repo;

import java.util.List;
import jakarta.persistence.EntityManager;
import jakarta.persistence.PersistenceContext;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;
import com.ignou.lab.admission.entity.Student;

@Repository
@Transactional
public class StudentRepository {

    @PersistenceContext
    private EntityManager em;

    @Transactional(readOnly = true)
    public List<Student> findAll() {
        return em.createQuery("from Student s order by s.id", Student.class).getResultList();
    }
}

package com.ignou.lab.admission.web;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import com.ignou.lab.admission.repo.StudentRepository;

@Controller
public class StudentController {

    private final StudentRepository repo;

    public StudentController(StudentRepository repo) {
        this.repo = repo;
    }

    @GetMapping("/students")
    public String list(Model model) {
        model.addAttribute("students", repo.findAll());
        return "students";
    }
}

<%@ page contentType="text/html;charset=UTF-8" %>
<%@ taglib prefix="c" uri="jakarta.tags.core" %>
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Students</title>
</head>
<body>
  <h1>Students (IGNOU database, via Hibernate/JPA)</h1>
  <table border="1" cellpadding="4">
    <tr><th>Id</th><th>Enrolment No</th><th>Name</th><th>Email</th><th>DOB</th><th>Programme</th><th>Courses</th></tr>
    <c:forEach items="${students}" var="s">
      <tr>
        <td>${s.id}</td>
        <td><c:out value="${s.enrolmentNo}"/></td>
        <td><c:out value="${s.name}"/></td>
        <td><c:out value="${s.email}"/></td>
        <td>${s.dob}</td>
        <td><c:out value="${s.programme}"/></td>
        <td><c:out value="${s.courses}"/></td>
      </tr>
    </c:forEach>
  </table>
  <p><a href="${pageContext.request.contextPath}/">Home</a></p>
</body>
</html>

package com.ignou.lab.admission.ioc;

public interface Teacher {
    String getName();
    String getFavouriteCourse();
}

package com.ignou.lab.admission.ioc;

import org.springframework.stereotype.Component;

/** New implementation of Teacher. The container creates it; nobody calls new. */
@Component
public class JavaTeacher implements Teacher {

    @Override
    public String getName() {
        return "Dr. Rao";
    }

    @Override
    public String getFavouriteCourse() {
        return "MCS-220 Web Technologies";
    }
}

package com.ignou.lab.admission.ioc;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class TeacherApp {

    public static void main(String[] args) {
        try (var ctx = new AnnotationConfigApplicationContext(JavaTeacher.class)) {
            Teacher teacher = ctx.getBean(Teacher.class); // asked for by interface, not by class
            System.out.println("Bean class : " + teacher.getClass().getSimpleName());
            System.out.println(teacher.getName() + " prefers " + teacher.getFavouriteCourse());
        }
    }
}