java学习-Spring

最新推荐文章于 2024-09-23 17:40:09 发布

vly521

最新推荐文章于 2024-09-23 17:40:09 发布

阅读量95

点赞数

本文链接：https://blog.csdn.net/vly521/article/details/104460903

版权

而在 Spring 中提供了 3 种方法进行配置：

在 XML 文件中显式配置
在 Java 的接口和类中实现配置
隐式 Bean 的发现机制和自动装配原则

方式选择的原则

在现实的工作中，这 3 种方式都会被用到，并且在学习和工作之中常常混合使用，所以这里给出一些关于这 3 种优先级的建议：

1.最优先：通过隐式 Bean 的发现机制和自动装配的原则。
基于约定由于配置的原则，这种方式应该是最优先的

好处：减少程序开发者的决定权，简单又不失灵活。
2.其次：Java 接口和类中配置实现配置
在没有办法使用自动装配原则的情况下应该优先考虑此类方法
好处：避免 XML 配置的泛滥，也更为容易。
典型场景：一个父类有多个子类，比如学生类有两个子类，一个男学生类和女学生类，通过 IoC 容器初始化一个学生类，容器将无法知道使用哪个子类去初始化，这个时候可以使用 Java 的注解配置去指定。
3.最后：XML 方式配置
在上述方法都无法使用的情况下，那么也只能选择 XML 配置的方式。
好处：简单易懂（当然，特别是对于初学者）
典型场景：当使用第三方类的时候，有些类并不是我们开发的，我们无法修改里面的代码，这个时候就通过 XML 的方式配置使用了。

通过 XML 配置装配 Bean

使用 XML 装配 Bean 需要定义对应的 XML，这里需要引入对应的 XML 模式（XSD）文件，这些文件会定义配置 Spring Bean 的一些元素，当我们在 IDEA 中创建 XML 文件时，会有友好的提示：

一个简单的 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>

这就只是一个格式文件，引入了一个 beans 的定义，引入了 xsd 文件，它是一个根元素，这样它所定义的元素将可以定义对应的 Spring Bean

一个简单的例子：
首先配置支持

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.10.RELEASE</version>
        </dependency>

applicationContext.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">
<bean id="hello" class="com.gg.pojo.Hello" scope="prototype">
    <property name="name" value="spring"/>
</bean>

</beans>

Hello

package com.gg.pojo;

public class Hello {
    private String name;

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    public void show(){
        System.out.println("Hello"+ name );
    }
}

    @Test
    public void hello(){
        ClassPathXmlApplicationContext cp = new ClassPathXmlApplicationContext("applicationContext.xml");

        Hello hello = (Hello) cp.getBean("hello");
        hello.show();
    }

![在这里插入图片描述](https://img-blog.csdnimg.cn/2020022315313418.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3ZseTUyMQ==,size_16,color_FFFFFF,
装配集合
有些时候我们需要装配一些复杂的东西，比如 Set、Map、List、Array 和 Properties 等

public class Student{
    
    private Long id;
    private List<String> list;
    private Map<String, String> map;
    private Properties properties;
    private Set<String> set;
    private String[] array;

    /* setter and getter */
}

<bean id="student" class="com.gg.pojo.Student">
    <!-- 装配Long类型的id -->
    <property name="id" value="1"/>
    
    <!-- 装配List类型的list -->
    <property name="list">
        <list>
            <value>value-list-1</value>
            <value>value-list-2</value>
            <value>value-list-3</value>
        </list>
    </property>
    
    <!-- 装配Map类型的map -->
    <property name="map">
        <map>
            <entry key="key1" value="value-key-1"/>
            <entry key="key2" value="value-key-2"/>
            <entry key="key3" value="value-key-2"/>
        </map>
    </property>
    
    <!-- 装配Properties类型的properties -->
    <property name="properties">
        <props>
            <prop key="prop1">value-prop-1</prop>
            <prop key="prop2">value-prop-2</prop>
            <prop key="prop3">value-prop-3</prop>
        </props>
    </property>
    
    <!-- 装配Set类型的set -->
    <property name="set">
        <set>
            <value>value-set-1</value>
            <value>value-set-2</value>
            <value>value-set-3</value>
        </set>
    </property>
    
    <!-- 装配String[]类型的array -->
    <property name="array">
        <array>
            <value>value-array-1</value>
            <value>value-array-2</value>
            <value>value-array-3</value>
        </array>
    </property>
</bean>

关于XML 配置文件：其中我么可以使用<import resource="xx.xml"/>标签将其他的xml文件导入当前的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">


<import resource="studentContext.xml"/>

<bean id="hello" class="com.gg.pojo.Hello" scope="prototype">
    <property name="name" value="spring"/>
</bean>

</beans>

ClassPathXmlApplicationContext cp = new ClassPathXmlApplicationContext("applicationContext.xml");

我们就可以使用applicationContext.xml直接注入创建studentContext.xml里面bean标签中的对象

当我们的对象属性中包含其他的对象时：比如有一个人的对象他包含一个狗的对象
以前使用的是 autowire=“byName” 或者 autowire="byType"属性进行自动注入，但是推荐使用第二个注解的方法进行自动注入

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:contest="http://www.springframework.org/schema/context"
       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
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-beans.xsd">
    <bean id="dog" class="com.gg.pojo.Dog"/>

    <bean id="p" class="com.gg.pojo.People" autowire="byType">
        <property name="name" value="郭建"/>
    </bean>

</beans>

注意其中的头文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:contest="http://www.springframework.org/schema/context"
       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
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-beans.xsd">

</beans>

不过现在多使用的是注解方法：
People

public class People {

    private String name;
    @Autowired
    //自动装配也可以使用 @Resource进行注入和@Autowired功能一样
    //默认是byname 如果不行 再使用bytayp
    private Dog dog;

    public People() {
    }

    public People(String name, Dog dog) {
        this.name = name;
        this.dog = dog;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }

    public String getName() {
        return name;
    }

    public Dog getDog() {
        return dog;
    }
}

Dog

public class Dog {
    public void sout(){
        System.out.println("wawawaaw...........");
    }
}

peopleContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:contest="http://www.springframework.org/schema/context"
       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
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-beans.xsd">
    <bean id="dog" class="com.gg.pojo.Dog"/>

    <bean id="p" class="com.gg.pojo.People">
        <property name="name" value="郭建"/>
    </bean>

</beans>

@Test
    public void ts(){
        ClassPathXmlApplicationContext cp = new ClassPathXmlApplicationContext("peopleContext.xml");
        People p = (People) cp.getBean("p");
        p.getDog().sout();
    }

AOP
什么是AOP：AOP（Aspect Oriented Programming）意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
在这里插入图片描述

Aop在Spring中的作用
提供声明式事务；允许用户自定义切面

横切关注点：跨越应用程序多个模块的方法或功能。即是，与我们业务逻辑无关的，但是我们需要关注的部分，就是横切关注点。如日志 , 安全 , 缓存 , 事务等等 …
切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。
通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。
目标（Target）：被通知对象。
代理（Proxy）：向目标对象应用通知之后创建的对象。
切入点（PointCut）：切面通知执行的 “地点”的定义。
连接点（JointPoint）：与切入点匹配的执行点。

SpringAOP中，通过Advice定义横切逻辑，Spring中支持5种类型的Advice: 在这里插入图片描述
即 Aop 在不改变原有代码的情况下 , 去增加新的功能

使用Spring实现Aop
官方参考文档
【重点】使用AOP织入，需要导入一个依赖包！

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.4</version>
</dependency>

一个aop的小例子：使用spring 的api接口实现
在这里插入图片描述
UserService

public interface UserService {
    public void add();
    public void delete();
    public void uodete();
    public void select();
}

UserServiceImpl

public class UserServiceImpl implements UserService {
    public void add() {
        System.out.println("增加了一个用户");
    }

    public void delete() {
        System.out.println("删除了一个用户");
    }

    public void uodete() {
        System.out.println("更新了一个用户");
    }

    public void select() {
        System.out.println("搜索用户");
    }
}

Log

public class Log implements MethodBeforeAdvice {
    public void before(Method method, Object[] objects, Object o) throws Throwable {

        System.out.println(o.getClass().getName()+"的"+method.getName());
    }
}

LogAfter

public class LogAfter implements AfterReturningAdvice {
    public void afterReturning(Object o, Method method, Object[] objects, Object o1) throws Throwable {
        System.out.println("结束增强");

    }
}

applicationContext.xml
注意头文件的改动

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

<bean id="userService" class="com.gg.imp.UserServiceImpl"/>
<bean id="log" class="com.gg.config.Log"/>
<bean id="logAfter" class="com.gg.config.LogAfter"/>


<aop:config>

    <aop:pointcut id="pointcut" expression="execution(* com.gg.imp.UserServiceImpl.*(..))"/>

    <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
    <aop:advisor advice-ref="logAfter" pointcut-ref="pointcut"/>

</aop:config>


</beans>

MyTest


public class MyTest {
    public static void main(String[] args) {

        ClassPathXmlApplicationContext cp = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userServiceImpl = (UserService) cp.getBean("userService");
        userServiceImpl.add();
    }
}

使用自定义类实现：
相比上面的增加一个类
Diylei

public class Diylei {

    public void before(){
        System.out.println("方法执行前");
    }
    public void after(){
        System.out.println("方法执行后");
    }
}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

<bean id="userService" class="com.gg.imp.UserServiceImpl"/>
 <bean id="diy" class="com.gg.diy.Diylei"/>


<aop:config>

    <aop:aspect ref="diy">
        <aop:pointcut id="point" expression="execution(* com.gg.service.UserService.*(..))"/>
        <aop:after method="before" pointcut-ref="point"/>
        <aop:after method="after" pointcut-ref="point"/>
    </aop:aspect>
</aop:config>


</beans>

只需要修改上面两处就可以了

方式三：使用注解

@Aspect
public class Diylei {
@Before("execution(* com.gg.service.UserService.*(..))")
    public void before(){
        System.out.println("方法执行前");
    }
}

还需要再开启注解

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
         http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

<bean id="userService" class="com.gg.imp.UserServiceImpl"/>
    <bean id="diylei" class="com.gg.diy.Diylei"/>
    <aop:aspectj-autoproxy/>
</beans>

使用Spring整合Mybatis
简单来说就是把工具类进行整合了使用注解方式进行实现
在这里插入图片描述
User

package com.gg.pojo;

public class User{
    private int id;
    private String name;
    private String pwd;

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }
    public User() {}

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

UserMapper


public interface UserMapper {
    List<User> getUserList();
}

UserMapper.xml

<mapper namespace="com.gg.mapper.UserMapper">

    <select id="getUserList" resultType="com.gg.pojo.User">
		select * from user ;
	</select>

</mapper>

UserMapperImpl

public class UserMapperImpl implements UserMapper {
    private SqlSessionTemplate sqlSession ;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession=sqlSession;
    }

    public List<User> getUserList(){
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.getUserList();

    }
}

applicationContext.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--1.数据源整合-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis? useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

    <!--2. 注入sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>

        <!--扫描包-->
        <property name="typeAliasesPackage" value="com.gg.pojo"/>
        <property name="mapperLocations" value="classpath:com/gg/mapper/xml/*.xml"/>
    </bean>

    <!--3.创建sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">

        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>

    <!--4. 将sqlSession放入Bean中-->
    <bean id="userMapperImpl" class="com.gg.imp.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>

</beans>


public class T {
    public static void main(String[] args) {

        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapperImpl = (UserMapper) context.getBean("userMapperImpl");
        for (User user : userMapperImpl.getUserList()) {
            System.out.println(user);
        }
    }
}

spring事物

一个执行删除的例子

在这里插入图片描述
User

public class User{
    private int id;
    private String name;
    private String pwd;

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }
    public User() {}

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getPwd() {
        return pwd;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

UserMapper

public interface UserMapper {
    List<User> getUserList();
    int delect();
}

UserMapper.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">


<mapper namespace="com.gg.mapper.UserMapper">

    <select id="getUserList" resultType="com.gg.pojo.User">
		select * from user ;
	</select>

    <delete id="delect">
        delete from user where id=5;
    </delete>



</mapper>

UserMapperImpl

public class UserMapperImpl implements UserMapper {
    private SqlSessionTemplate sqlSession ;

    public void setSqlSession(SqlSessionTemplate sqlSession) {
        this.sqlSession=sqlSession;
    }

    public List<User> getUserList(){
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.getUserList();

    }
    public int delect(){
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        return mapper.delect();

    }
}

applicationContext.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"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://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/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--1.数据源整合-->
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/mybatis? useUnicode=true&amp;characterEncoding=utf8&amp;useSSL=false"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

    <!--2. 注入sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>

        <!--扫描包-->
        <property name="typeAliasesPackage" value="com.gg.pojo"/>
        <property name="mapperLocations" value="classpath:com/gg/mapper/xml/*.xml"/>
    </bean>

    <!--3.创建sqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">

        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>


    <!--4. 将sqlSession放入Bean中-->
    <bean id="userMapperImpl" class="com.gg.imp.UserMapperImpl">
        <property name="sqlSession" ref="sqlSession"/>
    </bean>


    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <constructor-arg ref="dataSource" />
    </bean>
    
    <tx:advice id="txad" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <aop:config>
        <aop:pointcut id="txp" expression="execution(* com.gg.mapper.UserMapper.*(..))"/>
        <aop:advisor advice-ref="txad" pointcut-ref="txp"/>
    </aop:config>

其中的为开启事务配置

    <tx:advice id="txad" transaction-manager="transactionManager">
        <tx:attributes>
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <aop:config>
        <aop:pointcut id="txp" expression="execution(* com.gg.mapper.UserMapper.*(..))"/>
        <aop:advisor advice-ref="txad" pointcut-ref="txp"/>
    </aop:config>

public class T {
    public static void main(String[] args) {

        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserMapper userMapperImpl = (UserMapper) context.getBean("userMapperImpl");
        userMapperImpl.delect();
    }
}