使用 Java 初步搭建简单Spring 项目框架：

一、准备工作

1. 安装 Java Development Kit (JDK)，确保环境变量配置正确。

2. 安装一个集成开发环境（IDE），如 IntelliJ IDEA 或 Eclipse。

二、创建项目——具体步骤

在 ider 中创建一个新的 Maven 项目

• 使用 Maven：

  • 在项目创建向导中，选择 Maven 项目类型，并填写项目的基本信息

  • Maven 会自动生成一个基本的项目结构，包括src/main/java、src/test/java等目录。

  添加 Spring 依赖

  在项目的构建文件（pom.xml 对于 Maven）中添加 Spring 的依赖。

  Maven 导入 spring 核心基础 jar(在pom.xml中)

  将其复制进<dependencies></dependencies>之中

  <!-- spring-context -->
  ​
  <dependency>
  ​
  <groupId>org.springframework</groupId>
  ​
  <artifactId>spring-context</artifactId>
  ​
  <version>5.2.2.RELEASE</version>
  ​
  </dependency>

  编写 spring 配置文件

  ·在resources包中创建spring.xml文件，将其复制进去

  <?xml version="1.0" encoding="UTF-8"?>
  <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">
      
      配置
      
  </beans>

  创建各层包与对象 -（测试）

  在java包下创建自己的自定义名称包，首先创建model和test两个包，分别用于创建模型类和测试类；

  （在spring中创建并管理对象的方式有两种，二选一，建议用依赖注入方式）

  基于 xml 配置方式 -用来创建并管理对象

  （bean 配置需要 spring 管理的类

  id 生成的对象名

  class 全类名）

  1.在model包下创建Admin类，自定义成员变量与成员方法,并且在spring.xml中<beans></beans>中配置Admin；

  <bean id="admin" class="com.ffyc.springpro.model.Admin">
           <constructor-arg name="account" value="admin"></constructor-arg>
          <constructor-arg name="password" value="admin"></constructor-arg>
  /*依赖注入：在创建对象的时候，为对象中属性赋值注入两种方式：
                 1.通过属性注入，属性的set方法
                 2.通过构造方法注入 */
  </bean>

  ·2.在test包下创建test1类,在其内创建main方法，

  /*把生成对象的控制权，反转给spring框架，spring框架负责管理对象的整个生命周期的过程*/
  ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
  /*
  ApplicationContext是一个接口，代表了 Spring 的应用上下文。它提供了访问 Spring 容器中管理的 bean 的方法，以及处理应用程序事件等功能。
  new ClassPathXmlApplicationContext("spring.xml")创建了一个基于类路径的 XML 配置文件的应用上下文实例。这意味着 Spring 将在应用程序的类路径中查找名为 "spring.xml" 的配置文件，并根据其中的定义来创建和管理 bean。
  */
  ​
  Admin admin = (Admin) applicationContext.getBean("admin");
          Admin admin1 = applicationContext.getBean("admin",Admin.class);
  /*用applicationContext.getBean("admin",Admin.class);可获取Admin类对象*/
  ​
  System.out.println(admin);
  System.out.println(admin1);
  /* 输出并查看其是否创建成功 */

  3.成功后，创建dao包（连接数据库）与service包（逻辑处理层）

  用其模拟连接数据库与逻辑处理中多种方法

  分别创建AdminDao类与AdminService类,并在spring.xml中<beans></beans>中配置

  <bean id="admindao" class="com.ffyc.springpro.dao.AdminDao"></bean>
  <bean id="adminService" class="com.ffyc.springpro.service.AdminService"></bean>

  4.在AdminDao类创建save()方法，

  在AdminService类：创建AdminDao类对象（AdminDao adminDao;）作为成员变量（创建get,set方法）,创建saveAdmin()方法,并在里面调用adminDao.save();

  其需要在spring.xml中<beans></beans>中配置

  <bean id="adminService" class="com.ffyc.springpro.service.AdminService">
          <property name="adminDao" ref="admindao"></property>
  </bean>

  /name="adminDao" 对应 AdminDao adminDao ref="admindao" 对应 id="adminService"/

  5.在test1中创建AdminService对象（）并调用saveAdmin()以测试，（几个方法中自定义写sout语句，用于辨识）

  *依赖注入 -用来创建并管理对象 *

  指 Spring 创建对象的过程中，将对象依赖属性（简单值，集合，对象）通过配置设置给该对象。

  实现 IOC 需要 DI 做支持

  注入的方式：

  set 方法注入

  构造方法注入

  1.注解方式实现

  在 Spring 的 XML 配置文件中，可以使用<context:component-scan>元素来开启注解扫描。该元素指定要扫描的包路径，以便 Spring 能够自动发现并注册被注解标记的 bean。例如：

  <beans xmlns="http://www.springframework.org/schema/beans"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns:context="http://www.springframework.org/schema/context"
         xsi:schemaLocation="http://www.springframework.org/schema/beans
                             http://www.springframework.org/schema/beans/spring-beans.xsd
                             http://www.springframework.org/schema/context
                             http://www.springframework.org/schema/context/spring-context.xsd">
  ​
      <context:component-scan base-package="com.example"/>
  ​
  </beans>

  2.注解创建对象

  @Component(value=“admin”)等同于 <bean id="admin" class="全类名"></bean>

  @Service

  @Repository

  以上注解都可以实现创建对象功能，只是为了后续扩展功能，在不同的层使用不同的注解标记

  @Scope(value=“prototype”) 原型

  @Scope(value=“ singleton ”) 单例

  例子与讲解：

  1. • @Component注解是一个通用的注解，可以用于标记任何 Spring 管理的 bean。可以通过value属性指定 bean 的名称。例如：

  @Component(value="user")
  public class User {
      //...
  }

  在上面的代码中，@Component(value="user")标记了User类为一个 Spring 管理的 bean，其名称为 "user"。这等同于在 XML 配置文件中使用<bean id="user" class="com.example.User"/>定义一个 bean。

  • @Service、@Repository和@Controller注解是特定于不同层的注解，分别用于标记服务层、数据访问层和控制层的 bean。这些注解的使用可以提高代码的可读性和可维护性，同时也方便了后续的扩展和维护。例如：

  @Service
  public class UserService {
      //...
  }
  ​
  @Repository
  public class UserDao {
      //...
  }
  ​
  @Controller
  public class UserController {
      //...
  }

  在上面的代码中，@Service标记了UserService类为一个服务层的 bean，@Repository标记了UserDao类为一个数据访问层的 bean，@Controller标记了UserController类为一个控制层的 bean。

  • @Scope注解用于指定 bean 的作用域。默认情况下，Spring 中的 bean 是单例的，即每个 bean 在整个应用程序中只有一个实例。可以使用@Scope注解来改变 bean 的作用域。例如：

  @Component
  @Scope(value="prototype")
  public class User {
      //...
  }

  在上面的代码中，@Scope(value="prototype")指定了User类的 bean 为原型作用域，即每次从容器中获取该 bean 时都会创建一个新的实例。

  • @Scope(value="singleton")指定了 bean 为单例作用域，即整个应用程序中只有一个实例。这是 Spring 中默认的作用域。例如：

  @Component
  @Scope(value="singleton")
  public class UserService {
      //...
  }

  在上面的代码中，@Scope(value="singleton")指定了UserService类的 bean 为单例作用域。

  3.注解方式注入

  1、@Autowired

  这是 Spring 中最常用的依赖注入注解之一。它可以对成员变量、构造方法及方法参数进行标注，实现自动装配。当 Spring 容器在创建被标注的对象时，会自动查找匹配的 bean 并注入到相应的位置。例如：

  public class UserService {
      @Autowired
      private UserDao userDao;
  }

  2、@Resource

  此注解也用于依赖注入。它可以通过名称或类型来查找要注入的 bean。默认情况下，它先按名称进行匹配，如果找不到再按类型匹配。比如：

  public class OrderService {
      @Resource(name = "orderDaoImpl")
      private OrderDao orderDao;
  }

  3、@Inject

  @Inject来自 Java 的依赖注入标准（JSR-330），Spring 也支持该注解进行依赖注入。其用法与@Autowired类似。例如：

  public class ProductService {
      @Inject
      private ProductDao productDao;
  }

  4、@Value

  用于注入基本类型和字符串的值。可以从配置文件中读取属性值并注入到标注的成员变量中。例如：

  public class ConfigService {
      @Value("${app.name}")
      private String appName;
  }

  注解与 XML 的对比

  注解优点： 方便,直观,高效（代码少，没有配置文件的书写那么复杂）。

  注解缺点：以硬编码的方式写入到 Java 代码中，修改是需要重新编译代码的。

  xml 优点是： 配置和代码是分离的,在 xml 中做修改，无需编译代码，只需重

  启服务器即可将新的配置加载。

  xml 的缺点是：编写麻烦，效率低，大型项目过于复杂。

  Spring 数据访问层管理

  在 Spring 中，数据访问层（Data Access Layer，DAL）的管理是通过一系列技术和机制来实现的，以提供高效、可靠的数据访问。以下是关于 Spring 数据访问层管理的一些关键方面：

  1、Spring 数据访问技术整合

  1. JDBC 支持

     • Spring 对 JDBC（Java Database Connectivity）提供了强大的支持，通过 JdbcTemplate 简化了 JDBC 操作。它处理了资源管理、异常处理等繁琐的任务，让你专注于 SQL 语句和数据处理。

     • 例如，使用 JdbcTemplate 执行查询并将结果映射到 Java 对象：

       List<Customer> customers = jdbcTemplate.query("SELECT * FROM customers",
               (rs, rowNum) -> new Customer(rs.getString("name"), rs.getInt("age")));

  1. ORM 框架集成

     • Spring 可以与流行的对象关系映射（Object-Relational Mapping，ORM）框架如 Hibernate、MyBatis 等无缝集成。

     • 对于 Hibernate，Spring 提供了 LocalSessionFactoryBean 来配置 Hibernate 的 SessionFactory，并通过 HibernateTemplate 简化 Hibernate 的使用。

     • 在 MyBatis 中，SqlSessionFactoryBean 用于创建 MyBatis 的 SqlSessionFactory，并且可以使用 MapperFactoryBean 或 @MapperScan 注解来自动扫描和注册 MyBatis 的 Mapper 接口。

  2、事务管理

  1. 声明式事务

     • Spring 提供了声明式事务管理，通过使用 @Transactional 注解，可以在方法级别上轻松地指定事务的属性，如事务的传播行为、隔离级别等。

     • 例如：

       @Service
       public class CustomerService {
           @Autowired
           private CustomerRepository customerRepository;
  ​
           @Transactional
           public void saveCustomer(Customer customer) {
               customerRepository.save(customer);
               // 如果这里发生异常，事务将回滚
           }
       }

  2.编程式事务

  • 虽然声明式事务更常用，但在某些情况下，可能需要使用编程式事务管理。Spring 提供了 TransactionTemplate 来实现编程式事务。

  • 例如：

       TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
       transactionTemplate.execute(status -> {
           // 执行事务性操作
           return null;
       });

  3、数据访问对象（DAO）模式

  1. DAO 接口和实现

     • 在 Spring 中，通常采用数据访问对象（DAO）模式来封装数据访问逻辑。定义一个 DAO 接口，并提供一个具体的实现类。

     • 例如，定义一个客户 DAO 接口：

       public interface CustomerDao {
           List<Customer> findAllCustomers();
           Customer findCustomerById(int id);
           void saveCustomer(Customer customer);
       }

  • 然后实现这个接口：

       @Repository
       public class CustomerDaoImpl implements CustomerDao {
           @Autowired
           private JdbcTemplate jdbcTemplate;
  ​
           @Override
           public List<Customer> findAllCustomers() {
               return jdbcTemplate.query("SELECT * FROM customers",
                       (rs, rowNum) -> new Customer(rs.getString("name"), rs.getInt("age")));
           }
  ​
           // 其他方法的实现
       }

  1. 依赖注入 DAO

     • 通过 Spring 的依赖注入机制，可以将 DAO 对象注入到服务层或其他需要数据访问的组件中。

     • 例如，在服务类中注入客户 DAO：

       @Service
       public class CustomerService {
           private final CustomerDao customerDao;
  ​
           @Autowired
           public CustomerService(CustomerDao customerDao) {
               this.customerDao = customerDao;
           }
  ​
           public List<Customer> getAllCustomers() {
               return customerDao.findAllCustomers();
           }
       }

  4、数据库连接池

  1. 连接池配置

     • Spring 可以与各种数据库连接池集成，如 HikariCP、C3P0、Druid 等。配置连接池可以提高数据库连接的性能和效率。

     • 在 Spring Boot 中，可以通过在 application.properties 或 application.yml 文件中配置连接池属性来轻松使用连接池。例如，使用 HikariCP：

       spring.datasource.hikari.minimum-idle=5
       spring.datasource.hikari.maximum-pool-size=10
       spring.datasource.hikari.connection-timeout=30000

  1. 连接池管理

     • 连接池负责管理数据库连接的创建、复用和释放。它可以减少连接创建的开销，并确保连接的有效利用。

     • Spring 会自动管理连接池的生命周期，根据配置创建和销毁连接池，并在需要时提供数据库连接。

通过以上方式，Spring 提供了强大的数据访问层管理功能，使开发人员能够轻松地进行数据库操作、事务管理和连接池配置，提高应用程序的性能和可维护性。

开发步骤

1.下载 Spring jdbc 数据访问层 jar 包

<!-- spring-jdbc -->
​
<dependency>
​
<groupId>org.springframework</groupId>
​
<artifactId>spring-jdbc</artifactId><version>5.2.2.RELEASE</version>
​
</dependency>
​
<!-- 阿里数据源 -->
​
<dependency>
​
<groupId>com.alibaba</groupId>
​
<artifactId>druid</artifactId>
​
<version>1.1.10</version>
​
</dependency>

2.导入属性文件

<context:property-placeholder location="config.properties"/>

3.管理数据源对象

spring 管理数据库链接对象

本次采用阿里巴巴数据库连接管理对象

<bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
​
<property name="driverClassName" value="com.mysql.cj.jdbc.Driver"></property>
​
<property name="url" value="链接路径"></property>
​
<property name="username" value="数据库的账号"></property>
​
<property name="password" value="密码"></property>
​
<property name="initialSize" value="10"></property><!--初始化连接数量-->
​
<property name="maxActive" value="20"></property><!--最大连接数量-->
​
</bean>
​
    <!--
         配置spring中对jdbc进行封装的操作类JdbcTemplate
    -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="druidDataSource"></property><!--这里的name是自己的id，ref是上面阿里巴巴数据库连接管理对象的id-->
    </bean>

到此，最基本的spring项目搭建完成

三、集成mybatis框架

参考mybatis框架基础

在resources下创建mappers,和创建mybatis.xml，与spring.xml在一起

Spring 结合 mybatis 插件包，在pom.xml

<dependency>
​
    <groupId>org.mybatis</groupId>
​
    <artifactId>mybatis-spring</artifactId>
​
    <version>1.3.1</version>
​
</dependency>

配置 sqlSessionFactory 在spring.xml里

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
​
    <property name="dataSource" ref="dataSource"></property>
​
    <property name="configLocation" value="classpath:mybatis-config.xml"></property>
​
    <property name="mapperLocations" value="classpath:mappers/*Mapper.xml">
​
    </property>
​
</bean>

指定生成接口代理 在spring.xml里

<bean id="mapperFactory" 
​
    class="org.mybatis.spring.mapper.MapperScannerConfigurer">
​
    <property name="basePackage" value="com.ffyc.ssm.dao"></property>
​
    <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory">
​
    </property>
​
</bean>

创建mybatis.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
​
    <!--mybatis核心全局配置文件-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!-- 全局二级缓存开关 -->
        <setting name="cacheEnabled" value="true"/>
    </settings>
​
    <!--为类配置别名-->
    <typeAliases>
        <!--<typeAlias type="com.ffyc.mybatispro.model.Admin" alias="Admin"></typeAlias>-->
        <package name="com.ffyc.ssm.model"/>
    </typeAliases>
​
​
</configuration>

对 Spring 集成 MyBatis 框架步骤的详细分析：

一、添加依赖

通过在项目中添加<dependency>标签引入mybatis-spring插件包，版本为 1.3.1。这个插件包使得在 Spring 环境中使用 MyBatis 更加方便和高效。

二、配置 SqlSessionFactory

1. 在spring.xml

   文件中配置配置SqlSessionFactoryBean：

   • <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">定义了一个名为sqlSessionFactory的 Bean，其类型为org.mybatis.spring.SqlSessionFactoryBean。

   • <property name="dataSource" ref="dataSource"></property>将数据源（通常是数据库连接池）注入到SqlSessionFactory中，通过ref属性引用名为dataSource的 Bean。

   • <property name="configLocation" value="classpath:mybatis-config.xml"></property>指定 MyBatis 的配置文件路径，这里是类路径下的mybatis-config.xml文件。这个配置文件可以包含 MyBatis 的全局配置信息，如数据库连接信息、插件配置等。

   • <property name="mapperLocations" value="classpath:mappers/*Mapper.xml"></property>指定 MyBatis 的 Mapper XML 文件路径，这里是类路径下mappers目录下的所有以Mapper.xml结尾的文件。Mapper XML 文件中定义了 SQL 语句和映射关系。

三、指定生成接口代理

1. 配置MapperScannerConfigurer：

   • <bean id="mapperFactory" class="org.mybatis.spring.mapper.MapperScannerConfigurer">定义了一个名为mapperFactory的 Bean，其类型为org.mybatis.spring.mapper.MapperScannerConfigurer。

   • <property name="basePackage" value="com.ffyc.ssm.dao"></property>指定要扫描的包路径，MyBatis 会在这个包及其子包中查找 Mapper 接口，并生成代理对象。

   • <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>通过sqlSessionFactoryBeanName属性指定要使用的SqlSessionFactory的 Bean 名称，这里是前面配置的sqlSessionFactory。

三、运行项目

访问`http://localhost:8080/自定义路径，你应该能够看到响应。