SSM框架-Spring

最新推荐文章于 2022-03-07 18:54:56 发布
最新推荐文章于 2022-03-07 18:54:56 发布
阅读量112 收藏
点赞数
文章标签： spring java mysql spring boot 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39151123/article/details/109218282
版权

Spring

1. Spring概述

    Spring是应用full-stack轻量级框架，以IoC(Inverse Of Control : 控制反转)和AOP(Aspect Oriented Programming : 面向切面编程)为内核，提供了表现层SpringMVC和持久层Spring JDBC以及业务层事务管理等众多的企业级应用技术，还能整合开源世界中众多的第三方框架和类库。

2. Spring的优势

  1. 方便解耦，简化开发
    • 通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进行控制，编码硬编码所造成的过度程序耦合。
  2. AOP编程支持
    • 通过Spring的AOP功能，方便进行面向切面编程，许多不容易用传荣OOP实现的功能可以通过AOP轻松实现。
  3. 声明式事务的支持
    • 可以简化在事务管理方面的代码，通过声明的方式进行灵活的事务管理，提高开发效率和质量
  4. 方便程序的测试
    • 可以用非容器依赖的编程方式进行几乎所有的测试工作，测试的难度被降低了。
  5. 方便集成各种优秀框架
    • Spring提供了对各种邮箱框架的直接支持。
  6. 降低JavaEE API的使用难度
    • Spring对JavaEE API中的代码(JDBC、JavaMail、远程调用等)进行了封装，降低了使用API的难度。

3. Spring的IoC应用

1. 在Maven中导入Spring的坐标

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
    </dependencies>

2. Spring的主配置文件：applicationContext.xml

  1. 主配置的约束头信息
<?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>
  1. 简单的Spring配置文件
<!-- 配置service 
        id : 唯一标识
        class : 指定类的全类名
-->
<bean id="accountService" class="com.hsh.study.service.impl.AccountServiceImpl"></bean>

<!-- 配置dao -->
<bean id="accountDao" class="com.hsh.study.dao.impl.AccountDaoImpl"></bean>
  1. 常见属性标签
    1. bean标签：用于配置对象让Spring来创建。默认情况下Spring调用类中的无参构造函数，没有无参构造函数则不能创建成功
      • 属性：
        • id：给对象在容器总提供一个唯一标识。用于获取对象。
        • class：指定类的全限定类名。用于反射创建对象，默认情况下调用无参构造函数
        • scope：指定对象的作用范围。
          1. singleton：默认值，单例对象
          2. prototype：多例的
          3. request：在WEB中，Spring创建一个Bean对象，将对象存入request域中。
          4. session：在WEB中，Spring创建一个Bean对象，将对象存入session域中。
          5. global session：在WEB中，应用在Porlet环境，如果没有Porlet环境那么globalSession相当于Session。
        • init-method：指定类中的初始化方法名称。
        • destory-method：指定类中销毁方法的名称
        • factory-method：指定生产对象的静态方法（使用静态工厂初始化Bean时）
        • factory-bean：用于指定实例工厂bean的id（使用实例工厂初始化Bean时）
        • factory-method：用于指定实例工厂中创建对象的方法（使用实例工厂初始化Bean时）

3. Spring的执行方法

  1. 使用ApplicaionContext接口获取Spring的容器：ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
  2. 根据配置文件获取对象：AccountService accountService = ac.getBean("accountService",AccountService.class);
  3. 使用对象：accountService.saveAccount();

ApplicationContext和BeanFactory的区别：

  1. BeanFactory是Spring容器中的顶层接口。
  2. ApplicationContext是BeanFactory的子接口。
  3. BeanFactory和ApplicationContext创建对象的时间点不同；
    • BeanFactory：什么时候使用什么时候创建对象
    • ApplicationContext：只要读取完配置文件，默认情况下就会创建对象。

4. Spring的依赖注入

  1. 依赖注入概念：在编写程序时，通过IoC(控制反转)将对象的创建交给了Spring，但是代码中不可能出现没有依赖的情况。IoC解耦只是降低了代码间的依赖关系，但不会完全消除。
  2. 构造函数的注入（通过类中的构造函数给成员变量完成赋值的操作）
    1. 编写需要进行赋值的实体类
    public class User {
    private String username;
    private Integer age;
    private Date birthday;

    public User(String username, Integer age, Date birthday) {
        this.username = username;
        this.age = age;
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", age=" + age +
                ", birthday=" + birthday +
                '}';
    }
}
    1. 用配置文件通过构造函数对属性进行赋值
    <!-- 通过构造器进行属性注入 -->
<bean id="user" class="com.hsh.study.domain.User">
    <!-- 通过<constructor-arg>标签对构造函数中的属性进行赋值
            index：指定参数在构造函数参数列表的索引位置
            type：指定参数在构造函数中的数据类型
            name：指定参数在构造函数中的名称
            ==--- 上面用于指定给谁赋值，下面指定赋什么值 ---==
            value：能赋值的类型为基本数据类型和String类型
            ref：能赋值的类型是其他bean类型，必须通过配置文件配置bean
    -->
    <constructor-arg name="username" value="张三"></constructor-arg>
    <constructor-arg name="age" value="18"></constructor-arg>
    <constructor-arg name="birthday" ref="now"></constructor-arg>
</bean>

<!-- 引入日期 -->
<bean id="now" class="java.util.Date"></bean>
  3. set方法的注入（常用）
    1. 编写需要进行赋值的实体类
    public class User {
   private String username;
   private Integer age;
   private Date birthday;
   
   public String getUsername() {
       return username;
   }

   public void setUsername(String username) {
       this.username = username;
   }

   public Integer getAge() {
       return age;
   }

   public void setAge(Integer age) {
       this.age = age;
   }

   public Date getBirthday() {
       return birthday;
   }

   public void setBirthday(Date birthday) {
       this.birthday = birthday;
   }
   @Override
   public String toString() {
       return "User{" +
               "username='" + username + '\'' +
               ", age=" + age +
               ", birthday=" + birthday +
               '}';
   }
}
    1. 用配置文件通过构造函数对属性进行赋值
    <!-- 通过set方法注入 -->
<bean id="user" class="com.hsh.study.domain.User">
    <!-- 通过<property>标签对属性进行赋值
            name：找类中set方法后面的部分
            ref：给属性赋值是其他bean类型
            value：给属性赋值的是基本数据类型或者string类型
     -->
    <property name="username" value="李四"></property>
    <property name="age" value="16"></property>
    <property name="birthday" ref="now"></property>
</bean>

<!-- 引入日期 -->
<bean id="now" class="java.util.Date"></bean>
  4. 使用p名称空间注入（本质还是调用set方法）
    1. 编写需要进行赋值的实体类
    public class User {
   private String username;
   private Integer age;
   private Date birthday;
   
   public String getUsername() {
       return username;
   }

   public void setUsername(String username) {
       this.username = username;
   }

   public Integer getAge() {
       return age;
   }

   public void setAge(Integer age) {
       this.age = age;
   }

   public Date getBirthday() {
       return birthday;
   }

   public void setBirthday(Date birthday) {
       this.birthday = birthday;
   }
   @Override
   public String toString() {
       return "User{" +
               "username='" + username + '\'' +
               ", age=" + age +
               ", birthday=" + birthday +
               '}';
   }
}
    1. 用配置文件通过构造函数对属性进行赋值
    <!-- 导入p标签的约束文件 -->
xmlns:p="http://www.springframework.org/schema/p"
<!-- 通过p标签进行注入 -->
<bean id="user" class="com.hsh.study.domain.User"
      p:username="王五" p:age="18" p:birthday-ref="now"
></bean>

<!-- 引入日期 -->
<bean id="now" class="java.util.Date"
></bean>
  5. 注入集合属性
    1. 编写需要进行赋值的实体类
    public class Collection {
    private String[] myStrs;
    private List<String> myList;
    private Set<String> mySet;
    private Map<String,String> myMap;
    private Properties myProps;

    public void setMyStrs(String[] myStrs) {
        this.myStrs = myStrs;
    }

    public void setMyList(List<String> myList) {
        this.myList = myList;
    }

    public void setMySet(Set<String> mySet) {
        this.mySet = mySet;
    }

    public void setMyMap(Map<String, String> myMap) {
        this.myMap = myMap;
    }

    public void setMyProps(Properties myProps) {
        this.myProps = myProps;
    }

    public String[] getMyStrs() {
        return myStrs;
    }

    public List<String> getMyList() {
        return myList;
    }

    public Set<String> getMySet() {
        return mySet;
    }

    public Map<String, String> getMyMap() {
        return myMap;
    }

    public Properties getMyProps() {
        return myProps;
    }
}
    1. 用配置文件通过构造函数对属性进行赋值
    <!-- 集合的注入 -->
<bean id="collection" class="com.hsh.study.domain.Collection">
    <!-- 注入集合数据
            List结构：array、List、Set
            Map结构：map、properties、entry
     -->
    <!-- 数组注入 -->
    <property name="myStrs">
        <list>
            <value>AAA</value>
            <value>BBB</value>
            <value>CCC</value>
        </list>
    </property>
    <!-- list集合注入 -->
    <property name="myList">
        <array>
            <value>AAA</value>
            <value>CCC</value>
            <value>BBB</value>
        </array>
    </property>
    <!-- set集合注入 -->
    <property name="mySet">
        <set>
            <value>BBB</value>
            <value>AAA</value>
            <value>CCC</value>
        </set>
    </property>
    <!-- map集合注入 -->
    <property name="myMap">
        <map>
            <entry key="111" value="AAA"></entry>
            <entry key="222" value="BBB"></entry>
            <entry key="333" value="CCC"></entry>
        </map>
    </property>
    <!-- Props注入 -->
    <property name="myProps">
        <props>
            <prop key="333">AAA</prop>
            <prop key="222">CCC</prop>
            <prop key="111">BBB</prop>
        </props>
    </property>
</bean>

5. Spring基于注解的使用

  1. 在Maven中导入Spring的坐标
  2. 配置Spring的配置文件使得支持注解
    1. 配置文件约束信息中引入注解的约束
    <?xml version="1.0" encoding="UTF-8"?>
<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">
        
</bean>
    1. 在配置文件中开启对注解的支持
    <?xml version="1.0" encoding="UTF-8"?>
<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">
    <!-- 告知spring创建容器时要扫描的包 -->
    <context:component-scan base-package="com.hsh.study"></context:component-scan>
</beans>
  3. Spring的常用注解
    • 创建对象的：<bean id="" class="" ></bean>
      1. @Component()
        • 将资源交由Spring进行管理，相当于在xml中配置<bean>标签
        • 默认属性为value，value即是hean的id，如果不指定value属性则默认id为当前类名，首字母小写
      2. @Controller @Service @Repository
        • 这三个注释的作用与@Component的作用一致，只不过提供了更加明确的语义化
          • @Controller：一般用于表现层
          • @Service：一般用于业务层
          • @Repository：一般用于持久层
    • 用于注入数据的：<property name="" ref="" /> <property name="" value="" />
      1. @Autowired
        • 自动按照类型注入。当使用注解注入属性时，可以不用声明set方法。只能注入其他bean类型。当有多个类型匹配时，使用要注入的对象变量名称作为bean的id。
      2. @Qualifier
        • 在自动按照类型的基础上，再按照Bean的id注入。在给字段注入时不能独立使用，必须和@Autowired一起使用；但是给方法参数注入时可以独立使用。
        • value：指定bean的id
      3. @Resource
        • 直接按照Bean的id进行注入。也是只能注入其他Bean类型
        • name：指定bean的id
      4. @Value
        • 注入基本数据类型和String类型的数据
        • value：用于指定值
    • 用于改变作用范围的：<bean id="" class="" ==scope=""==> </bean>
      1. @Scope
        • 指定bean的作用范围
        • value：指定范围的值（==singleton==、==prototype==、request、session、globalsession）
    • 和生命周期相关的：<bean id="" class="" ==init-method=""== ==destory-method=""== />
      1. @PostConstruct
        • 用于指定初始化方法
      2. @PreDestroy
        • 用于指定销毁方法
    • 用于纯注解配置的注解
      1. @Configuration
        • 作用：用于指定当前类是一个spring的配置类，当创建容器时会从该类上加载注解。获取容器时需要使用AnnotationApplicationContext（有@Configuration注解的类.class）
        • value：用于指定配置类的字节码
        • 注：当配置类作为AnnotationConfigApplicationContext对象创建的参数时，该注解可以不写。
      2. @ComponentScan
        • 作用：用于指定Spring再初始化容器时要扫描的包。作用和在spring的xml配置文件中的<context:component-scan base-package="com.hsh.study" />的作用相同
        • basePackages：用于指定要扫描的包，和注解中的value属性作用一致。
      3. @Bean
        • 作用：该注解只能写在方法上，表明使用此方法创建一个对象并放入Spring的容器中
        • name：给当前的@Bean注解方法创建的对象指定一个名称
      4. @PropertySource
        • 作用：用于加载.properties文件中的配置。例如当配置数据源时，可以把连接数据库的信息写道properties配置文件中，使用注解指定配置文件的位置。
        • value[]：用于指定properties文件位置。如果是在类路径下，需要写上==classpath:==
      5. @Import
        • 作用：用于导入其他配置类，在引入其他配置时可以不用再写@Configuration注解。
        • value[]：用于指定其他配置类的字节码
  4. Spring使用XML和使用注解配置的优劣
    1. 使用注解的优势：配置简单，维护方便，适用于Bean的是实现类由用户自己开发
    2. 使用XML的优势：修改时不需要改源码，不涉及重新编译和部署。适用于Bean来自第三方，使用其他的Bean。

6. Spring中使用纯注解配置

  1. 创建一个主配置类
//@Configuration
@ComponentScan("com.hsh.study")
@Import(JdbcConfig.class)
@PropertySource("classpath:jdbcConfig.properties")
public class SpringConfiguration {

}
  1. 创建JDBC配置类
public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    /**
     * 创建QueryRunner对象
     * @param dataSource
     * @return
     */
    @Bean(name = "runner")
    @Scope("singleton")
    public QueryRunner createQueryRunner(@Qualifier("ds1") DataSource dataSource){
        return new QueryRunner(dataSource);
    }
    /**
     * 创建数据库连接对象
     * @return
     */
    @Bean("ds1")
    public DataSource createDataSource(){
        try{
            ComboPooledDataSource ds = new ComboPooledDataSource();
            ds.setDriverClass(driver);
            ds.setJdbcUrl(url);
            ds.setUser(username);
            ds.setPassword(password);
            return ds;
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }
}
  1. 使用注释完成创建对象和注入
//1. 业务层
@Service("accountService")
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    @Override
    public List<Account> findAll() {
        return accountDao.findAll();
    }
}
//2. 持久层
@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {
    @Autowired
    private QueryRunner runner;

    @Override
    public List<Account> findAll() {
        try {
            return runner.query("select * from account",new BeanListHandler<Account>(Account.class));
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }
}
  1. 测试
ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        // 基于注解创建applicationContext
        AccountService accountService = applicationContext.getBean("accountService", AccountService.class);
        List<Account> accounts = accountService.findAll();
        for (Account account1 : accounts){
            System.out.println(account1);
        }

4. Spring整合Junit

1. 导入整合junit的jar包

<dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.0.2.RELEASE</version>
    </dependency>

2. 使用注解@RunWith代替原有运行器

@RunWith(SpringJUnit4ClassRunner.class)
public class JdbcTest2 {
    @Test
    public void test() {
    }
}

3. 使用@ContextConfiguration指定spring配置文件位置

  1. @ContextConfiguration属性：
    • locations属性：用于指定配置文件的位置。位于类路径下需使用classpath:表示。
    • calsses属性：用于指定注解的类。当不使用xml时，需要用此属性指定注解类的位置。
  2. 应用
@RunWith(SpringJUnit4ClassRunner.class)
// 使用XML配置文件时
@ContextConfiguration(locations = {"classpath:applicationContext.xml"})
// 使用注解时
@ContextConfiguration(classes = {config.SpringConfiguration.class})
public class JdbcTest2 {
    @Test
    public void test() {
    }
}

4. 使用@Autowired给变量注入数据

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {config.SpringConfiguration.class})
public class JdbcTest2 {
    @Autowired
    private AccountService accountService;
    @Test
    public void test() {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfiguration.class);
        accountService = applicationContext.getBean("accountService", AccountService.class);
        List<Account> accounts = accountService.findAll();
        for (Account account1 : accounts){
            System.out.println(account1);
        }
    }
}

5. Spring的AOP

1. 概念：

AOP（Aspect Oriented Programming）面向切面编程。利用AOP对业务逻辑的各个部分进行隔离，从而降低业务逻辑各部分之间的耦合度

2. AOP的作用及优势

  1. 作用：在程序运行期间，在不修改源码的基础上对已有方法进行增强。
  2. 优势：①减少重复代码②提高开发效率③维护方便

3. AOP中相关的术语

  1. JoinPoint（连接点）：连接点指的是哪些被拦截到的点。在spring中，这些点指的是方法，因为spring只支持方法类型的连接点。
  2. Pointcut（切入点）：切入点指的是对哪些连接点进行拦截的定义。
  3. Advice（通知/增强）：通知是指拦截到JoinPoint后所做的事情便是通知。
    • 通知的类型：前置通知，后置通知，异常通知，最终通知和环绕通知。
  4. Introduction（引介）：引介是一种特殊的通知在不修改类代码的前提下，Introduction可以在运行期间为类动态的添加一些方法或者Field。
  5. Target（目标对象）：代理的目标对象。
  6. Weaving（织入）：指把增强应用到目标对象来创建新的代理对象的过程。
  7. Proxy（代理）：一个类被AOP织入增强后，就产生了一个结果代理类。
  8. Aspect（切面）：是切入点和通知（引介）的结合。

3. AOP的使用

  1. 在Maven中引入Spring的AOP坐标
<!-- AOP坐标 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.0.2.RELEASE</version>
</dependency>
  1. 在spring的配置文件中导入约束
    1. spring-AOP的约束头信息
    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
    
</beans>
    1. spring-AOP的配置
      • execution表达式
        1. 在AOP中使用execution表达式首先要导入表达式的坐标
        <!-- AOP使用execution表达式坐标 -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.8.7</version>
</dependency>
        1. execution表达式的使用方法
          • 普通的表达式：权限修饰符 返回值类型 包名.包名...类名.方法名(参数列表)
          • 标准表达式写法：public void com.hsh.study.service.impl.AccountServiceImpl.findAll()
          • 权限修饰符可以省略，返回值类型使用通配符代替：* com.hsh.study.service.impl.AccountServiceImpl.findAll()
          • 包名使用通配符代替，几个类几个通配符：* *.*.*.*.*.AccountServiceImpl.findAll()
          • 包名可以使用..表示当前包及其子包：* *..AccountServiceImpl.findAll()
          • 方法名和类名都可以使用通配符：* *..*.*()
          • 参数列表：
            1. 基本数据类型直接写名称：int
            2. 引用数据类型写包名.类名的方式 java.lang.String
            3. 使用..表示有无参数均可，有参数可以为任意类型
          • 全通配写法：execution(* *..*.*(..))
      • AOP的具体配置
        1. 基本配置
        <!-- 首先导入对应的bean -->
<bean id="accountService" class="..."></bean>
<!-- 导入配置方法的bean -->
<bean id="logger" class="..." ></bean>
<!-- 配置aop -->
<aop:config>
    <!-- 配置切入点表达式<aop:pointcut />
            id：指定表达式唯一标识
            expression：指定表达式内容
         此标签写在<aop:aspect>内部表示当前切面可用
         此标签写在<aop:aspect>外部表示所有切面可用
    -->
    <aop:pointcut id="pt1" expression="execution(* *..*.*(..))"/>
<!-- 配置切面 -->
    <aop:aspect id="logAdvice" ref="transactionManager">
        <!-- 配置前置通知" -->
        <aop:before method="beforePringLog" pointcut-ref="pt1" />
        <!-- 配置后置通知 -->
        <aop:after-returning method="afterReturningPringLog" pointcut-ref="pt1" />
        <!-- 配置异常通知 -->
        <aop:after-throwing method="afterThrowingPringLog" pointcut-ref="pt1" />
        <!-- 配置最终通知 -->
        <aop:after method="afterPringLog" pointcut-ref="pt1" />
        <!-- 配置环绕通知 -->
        <!-- <aop:around method="aroundPrintLog" pointcut-ref="pt1" />-->
    </aop:aspect>
</aop:config>
        1. 环绕通知配置
          • 类中
          public Object aroundPrintLog(ProceedingJoinPoint pjp){
Object resultValue = null;
try{
    // 得到方法执行所需的参数
    Object[] args = pjp.getArgs();
    // 执行前置通知
    System.out.println("前置通知");
    // 执行切入点方法
    resultValue = pjp.proceed(args);
    // 执行后置通知
    System.out.println("后置通知");
    return resultValue;
}catch (Throwable e){
    System.out.println("异常通知");
    throw new RuntimeException(e);
}finally {
    System.out.println("最终通知");
}
        }
        * 配置文件中

        <bean id="accountService" class="..."></bean>

        <bean id="logger" class="..." ></bean>

        <aop:config>

        <aop:pointcut id="pt1" expression="execution(* ...*(..))"/>

        <aop:aspect id="logAdvice" ref="transactionManager">


        </aop:aspect>
        </aop:config>
        ```
  2. 基于注解的Spring-AOP配置
    1. 在配置文件中导入AOP相关的约束头信息
    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:aop="http://www.springframework.org/schema/aop"
    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/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
</bean>
    1. 指定Spring注解所需扫描的包,并开启对注解AOP的支持
    <!-- 需要扫描的包 -->
<context:component-scan base-package="com.hsh.study"></context:component-scan>
<!-- 开启对注解AOP的支持 -->
<aop:aspectj-autoproxy/>
    1. 针对各实体类进行注解配置
    2. 在通知类中使用注解进行通知
      • 在通知类上使用@Aspect注释表明这是一个切面类
      @Component("logger")
@Aspect
public class Logger {

}
      • 切入点表达式注解
        1. @Aspect
          • 作用：指定切入点表达式
          • value：指定表达式的内容
      • 针对AOP的四种状态对应的注释
        1. @Before
          • 作用：将当前方法看作前置通知
          • value：用于指定切入点表达式，还可以指定切入点表达式的引用
        2. @After-Returning
          • 作用：将当前方法看作后置通知
          • value：用于指定切入点表达式，还可以指定切入点表达式的引用
        3. @AfterThrowing
          • 作用：将当前方法看作异常通知
          • value：同上
        4. @After
          • 作用：将当前方法看作最终通知
          • value：同上
        5. @Around
          • 作用：将当前方法看作环绕通知
          • value：同上 @Around("pt1()") //引入切入点时括号要加上
    3. 使用纯注解配置时
      • 在配置类上使用注解：@EnableAspectJAutoProxy即可

6. Spring中的JdbcTemplate

1. 概念

JdbcTemplate是Spring框架中提供的一个对象，是对原始JDBC API的简单封装。其中提供了许多的操作模板类。

  1. 操作关系数据库：JdbcTemplate、HibernateTemplate
  2. 操作nosql数据：RedisTemplate
  3. 操作消息队列：JmsTemplate

2. 基于Spring的JdbcTemplate所必须的jar包或坐标

<!-- JdbcTemplate坐标 -->
 <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.0.2.RELEASE</version>
</dependency>
<!-- 事务控制坐标 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.0.2.RELEASE</version>
</dependency>

3. Spring-JdbcTemplate的使用

1. 编写Spring的配置文件
  1. 导入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>
  1. 配置相应的数据源
<!-- 使用c3p0数据库连接池时 -->
    <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/spring?useSSL=false" />
        <property name="user" value="root" />
        <property name="password" value="123" />
    </bean>
    <!-- 使用Spring内置数据源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.driverClass}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>
    <!-- 使用外部配置文件的Spring内置数据源时 -->
    <!-- 引入外部配置文件 -->
    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:jdbc.properties"></property>
    </bean>
    <!-- 使用注解引入外部文件时 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
2. 使用JdbcTemplate实现增删改查操作
  1. 在配置文件中配置JdbcTemplate
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource" />
</bean>
  1. 可以直接使用JdbcTemplate实现增删改查操作
3. 在Dao中使用JdbcTemplate
  1. 不通过继承JdbcDaoSupport来简化获取JdbcTemplate的操作（用于xml配置和注解配置中）
    1. 在Dao实现类中添加jdbcTemplate属性
    private JdbcTemplate jdbcTemplate;

// 添加注入
public void setJdbcTemplate(JdbcTemplate jdbcTemplate){
    this.jdbcTemplate = jdbcTemplate;
}
    1. 在配置文件中添加Dao实现类的bean
    <bean id="accountDao" class="...AccountDaoImpl">
    <property name="jdbcTemplate" ref="jdbcTemplate" />
</bean>
    1. 使用jdbcTemplate属性执行数据库操作
  2. 通过继承JdbcDaoSupport来简化获取JdbcTemplate的操作（仅限于xml配置中）
    1. 在Dao实体类中继承JdbcDaoSupport，不用添加jdbcTemplate属性
    public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao { }
    1. 在配置文件中添加Dao实体类的Bean
    <bean id="accountDao" class="..AccountDaoImpl">
    <!-- 可以配置JdbcTemplate也可以配置DataSource 配置一个即可-->
    <!-- 配置JdbcTempldate -->
    <property name="jdbcTemplate" ref="jdbcTemplate" />
    <!-- 配置DataSource -->
    <property name="dataSource" ref="dataSource" />
</bean>
    1. 调用父类的方法super.getJdbcTemplate()来执行相应的数据库操作

7. Spring中的事务控制

  • Spring中关于事务控制的API

1. PlatformTransactionManager（Spring中的事务管理器）

PlatformTransactionManager接口提供了事务操作的方法，其中包含3各具体的操作：

  1. 获取事务状态信息TransactionStatus getTransaction(TransactionDefinition definition)
  2. 提交事务void commit(TransactionStatus status)
  3. 回滚事务void rollback(TransactionStatus status)
    真正使用的是PlatformTransactionManager接口的实体类：
  4. org.springframework.jdbc.datasource.==DataSourceTransactionManager== 使用Spring JDBC或iBatis进行持久化数据时使用
  5. org.springframework.orm.hibernate5.==HibernateTransactionManager== 使用Hibernate版本进行持久化数据时使用
2. TransactionDefinition

TransactionDefinition是事务的信息定义对象，方法如下：

  1. 获取事务对象名称：String getName()
  2. 获取事务隔离级别：int getIsolationLevel()
    • 默认级别，归属以下某一种：ISOLATION_DEFAULT
    • 可以读取未提交数据：ISOLATION_READ_UNCOMMITTED
    • 只能读取已提交数据，解决脏读问题(Oracle默认级别)：ISOLATION_READ_COMMITTED
    • 是否读取其他事务提交修改后的数据，解决不可重复读问题(MySql默认级别)：ISOLATION_REPEATABLE_READ
    • 是否读取其他事务提交添加后的数据，解决幻影读的问题：ISOLATION_SERIALIZABLE
  3. 获取事务传播途径：int getPropagationBehavior()
    • REQUIRED：如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到该事务中。（默认值）
    • SUPPORTS：支持当前事务，如果当前没有事务，就通过非事务方式执行
    • MANDATORY：使用当前的事务，如果当前没有事务则抛异常
    • REQUERS_NEW：新建事务，如果当前在事务中，则将当前事务挂起
    • NOT_SUPPORTED：以非事务的方式执行操作，如果当前存在事务，则将当前事务挂起
    • NEVER：以非事务的方式运行，如果当前存在事务，抛出异常
    • NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行REQUIRED类似的操作
  4. 获取事务超时时间：int getTimeout()
    • 默认值为-1，没有超时限制。如果有则以秒为单位进行设置
  5. 获取事务是否只读：boolean isReadOnly()
    • 只读事务：查询
    • 读写型事务：增删改
3. TransactionStatus

TransactionStatus接口提供某个时间点上事务对象的状态信息，其中有6个具体的操作

  1. 刷新事务：void flush()
  2. 获取是否存在存储点：boolean hasSavepoint()
  3. 获取事务是否完成：boolean isCompleted()
  4. 获取事务是否为新的事务：boolean isNewTransaction()
  5. 获取事务是否回滚：boolean isRollbackOnly()
  6. 设置事务回滚：void setRollbackOnly()

  • Spring中事务控制的具体操作

1. 导入Spring事务控制的相关坐标
<!-- JDBC相关坐标 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.0.2.RELEASE</version>
</dependency>
<!-- 事务控制相关坐标 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
    <version>5.0.2.RELEASE</version>
</dependency>
2. 在配置文件中导入aop和tx约束
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">

</beans>
3. 配置Bean、数据源、事务控制、AOP
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-3.1.xsd">

    <!-- 配置service -->
    <bean id="accountService" class="com.hsh.study.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"></property>
    </bean>

    <!-- 配置DAO -->
    <bean id="accountDao" class="com.hsh.study.dao.impl.AccountDaoImpl">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    <!-- 配置数据源 -->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="${jdbc.classDriver}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>

    <!-- 配置数据库配置文件 -->
    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="classpath:jdbc.properties" />
    </bean>

    <!-- 配置事务管理器 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <!-- 导入数据源 -->
        <property name="dataSource" ref="dataSource" />
    </bean>

    <!-- 事务的配置 -->
    <tx:advice id="txAdvice" transaction-manager="transactionManager" >
        <!-- 配置事务的属性 -->
        <tx:attributes>
            <tx:method name="*" read-only="false" propagation="REQUIRED"/>
            <tx:method name="find*" read-only="true" propagation="SUPPORTS"/>
        </tx:attributes>
    </tx:advice>
    <!-- AOP的配置 -->
    <aop:config>
        <!-- 配置切入点表达式 -->
        <aop:pointcut id="pt1" expression="execution(* com.hsh.study.service.impl.*.*(..))"/>
        <!-- 配置AOP -->
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor>
    </aop:config>
</beans>

  • Spring中事务控制的具体操作（使用注解开发）

  1. 主注解类的配置
// 声明式配置类
@Configuration
// 告诉Spring要扫描的包
@ComponentScan("com.hsh.study")
// 导入的另一个配置类
@Import(JdbcConfig.class)
// 配置文件的声明
@PropertySource("classpath:jdbc.properties")
// 开启注解AOP支持
@EnableAspectJAutoProxy
// 开启注解事务支持
@EnableTransactionManagement
public class SpringConfig {

}
  1. Jdbc注解类的配置
public class JdbcConfig {
    // @Value：表示引入配置文件中的值
    @Value("${jdbc.classDriver}")
    private String classDriver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String username;
    @Value("${jdbc.password}")
    private String password;
    // 声明jdbcTemplate
    @Bean("jdbcTemplate")
    public JdbcTemplate createJdbcTemplate(DataSource dataSource){
        return new JdbcTemplate(dataSource);
    }
    /**
     * 创建事务管理器
     * Bean注解不配值时,默认类名首字母小写如DataSourceTransactionManager变成dataSourceTransactionManager
     */
    @Bean
    public DataSourceTransactionManager transactionManager(DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }
    // 声明数据源
    @Bean("dataSource")
    public DataSource createDataSource(){
        try {
            DriverManagerDataSource manager = new DriverManagerDataSource();
            manager.setDriverClassName(classDriver);
            manager.setUrl(url);
            manager.setUsername(username);
            manager.setPassword(password);
            return manager;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}
  1. 业务层实现
@Service("accountService")
@Transactional(readOnly = true,propagation = Propagation.SUPPORTS)
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    @Override
    @Transactional(readOnly = false,propagation = Propagation.REQUIRED)
    public void transfer(String sourceName, String targetName, Double money) {
        // 获取两个用户
        Account source = accountDao.findByName(sourceName);
        Account target = accountDao.findByName(targetName);
        // 执行转账操作
        source.setMoney(source.getMoney()-money);
        target.setMoney(target.getMoney()+money);
        // 执行更新操作
        accountDao.update(source);
        accountDao.update(target);
    }
  1. 持久层实现
@Repository("accountDao")
public class AccountDaoImpl implements AccountDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Override
    public Account findById(Integer accountId) {
        List<Account> accounts = jdbcTemplate.query("select * from account where id = ?",
                new BeanPropertyRowMapper<Account>(Account.class), accountId);
        return accounts.isEmpty()?null:accounts.get(0);
    }
    @Override
    public Account findByName(String accountName) {
        List<Account> accounts = jdbcTemplate.query("select * from account where name = ?",
                new BeanPropertyRowMapper<Account>(Account.class), accountName);
        if (accounts.isEmpty()){
            return null;
        }
        if (accounts.size() > 1){
            throw new RuntimeException("结果集不唯一");
        }
        return accounts.get(0);
    }
    @Override
    public void update(Account account) {
        jdbcTemplate.update("update account set money = ? where id = ?",
                account.getMoney(),account.getId());
    }
}
青丶空
关注
SSM框架之Spring简介
weixin_45868290的博客
04-09 231
1. 普通容器普通容器只是负责存储数据(对象)，例如我们在JavaSE中学习的数组、List、Map等等，可以让我们使用它存储数据、获取数据，不具备其它复杂的功能2. 复杂容器复杂容器不仅要负责存储对象，还需要具备创建对象、调用对象方法、管理对象生命周期、并且在一定情况下负责销毁对象。例如我们之前学习的Tomcat就是一个复杂容器，它能够负责创建Servlet、Filter、Listener等等对象，并且管理他们的生命周期，在生命周期的不同阶段调用他们的不同方法。
ssm框架--spring mvc实现文件上传
06-09
SSM框架，全称Spring、Spring MVC和MyBatis，是Java Web开发中常见的三大组件。Spring作为核心容器，管理着应用对象的生命周期和依赖注入；Spring MVC是Spring的Web模块，负责处理HTTP请求和响应；MyBatis则是一个...
SSM中（Spring-SpringMVC-Mybatis）（一：概念）
weixin_34162695的博客
01-07 356
一：Spring： 参照我的另一篇博客： http://www.cnblogs.com/GH0522/p/8127530.html 二:SpringMVC: 流程图： SpringMVC接口解释 DispatcherServlet： Spring提供的前端控制器，所有的请求都有经过它来统一分发。在DispatcherServlet将请...
SSM中 spring.xml 配置文件
dianqiong7545的博客
06-03 176
<!--扫描service的impl--><context:component-scan base-package="com.aaa.ssm.service.impl"></context:component-scan><!--加载jdbc.properties--><context:property-placeholder loca...
SSM之spring
weixin_44286776的博客
06-28 593
1.IOC 1.1复杂属性赋值 1.1.1普通的bean对象赋值 setter注入 <bean class="bean.User" id="user"> <property name="name" value="张三"></property> <property name="sex" value="男"></property> <property name="age" value="15"></proper
SSM-Spring
weixin_58862969的博客
02-21 361
SSM介绍: 1、Spring是一个开源免费的框架 , 容器 . 2、Spring是一个轻量级的框架 , 非侵入式的 . 3、控制反转 Ioc , 面向切面 Aop 4、对事物的支持 , 对框架的支持 两大核心：Ioc(控制反转) Aop(面向切面编程) 什么是Ioc: ...
Spring+SpringMVC+MyBatis SSM框架整合工程实例 完整版源码.zip
05-03
Spring+SpringMVC+MyBatis整合工程实例 完整版源码，这个SSM框架整合工程是基于IntelliJ IDEA完成的的，工程里面配置文件均有注释，可直接拷贝使用（工程代码可导入IDEA中直接运行）,可供学习设计参考。
ssm整合--spring-mybatis-spring-mvc
03-06
ssm整合--spring-mybatis-spring-mvc,内含sql文件，全套整合，简洁，详细地址访问：https://blog.csdn.net/qq_40374604/article/details/88256278
SSM框架-详细整合教程 (2).pdf
11-13
SSM框架，即Spring、SpringMVC和MyBatis的集成，是Java开发中常见的Web应用程序框架组合。本文将详细讲解如何整合这三个组件，以构建一个功能完备的J2EE项目。 **1. Spring框架** Spring是一个轻量级的Java开发框架...
基于SSM框架的校园交易平台代码 - java - ssm- spring - springmvc - mybatis - 代码
最新发布
01-12
基于SSM框架的校园交易平台代码 | java | ssm| spring | springmvc | mybatis | 代码 | 网站 1、技术栈：微信小程序，springboot，uniapp，vue，ajax，maven，mysql，MyBatisPlus 2、系统的实现 用户信息 图片素材 ...
SSM空白框架
07-27
这是整合之后的空白的SSM开发框架
空白SSM框架
11-11
空白SSM框架
SSM空框架SSM空框架
06-15
SSM空框架
空的的SSM项目
06-05
一个空的SSM项目，整合了Mybatis逆向工程和Swagger，帮助新人快速搭建项目
基于SSM（Spring-SpringMVC-MyBatis）的高级整合（增删改查功能）电影
01-17
基于SSM（Spring-SpringMVC-MyBatis）的高级整合（增删改查功能）电影
SSM——Spring
m0_46692607的博客
03-07 671
1.入门 1.创建maven项目，导入spring-context坐标 2.创建UserDao接口和实现该接口的UserDaoImpl类 3.创建Spring配置文件applicationContext.xml 4.在applicationContext.xml中注册UserDaoImpl,指定类的id和全限定名 5.利用ClassPathXmlApplicationContext创建对象管理容器context 6.根据context.getBean(“类id”,类.class)从容器中获得类的实例对
SSM框架之Spring
尝胆的世界
03-11 404
认识spring Spring是一个轻量级的 控制反转(IOC) 和面向切面编程(AOP) 的容器框架 轻量级：从大小与开销两方面 都是轻量级的。spring框架的jar 很小，运行spring框架的开销很小 非入侵：在代码开发中，一般不会入侵spring代码 控制反转(IOC)：把对象的创建权利交给了容器。 面向切面编程(AOP)： 为什么使用spring框架： 降低组件...
SSM Spring篇
qq_41315339的博客
04-16 186
Spring框架 Spring是一个基于IOC和AOP的结构J2EE系统的框架（容器） ioc IOC容器 控制的实现方式 是Spring的基础，Inversion Of Control，是一种设计思想，di依赖注入是实现ioc的一种方式 是一种通过描述（xml或者注解）并通过第三方或获取对象的方式 ①多态实现 耦合度太高 传统开发 需求发生更改的时候需要修改impl下的东西 public interface UserDao{void getUser()} //UserDao
ssm框架之spring
eather_liang的博客
07-29 174
1.Spring简介 Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。 （1）. IOC：控制反转。Spring通过一种称作控制反转（IoC）的技术促进了松耦合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。不是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。 ...
ssm框架和spring区别
04-23
SSM框架和Spring框架分别有以下几个组成部分： 1. Spring框架：核心容器、AOP、数据访问/集成、Web、测试等模块。Spring框架的目的是为Java应用程序提供企业级开发的基础架构。 2. SSM框架：Spring + Spring MVC +...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值