Spring学习笔记

最新推荐文章于 2023-06-10 19:11:45 发布

夏沫y

最新推荐文章于 2023-06-10 19:11:45 发布

阅读量191

点赞数

文章标签： java spring

本文链接：https://blog.csdn.net/weixin_45768223/article/details/115342001

版权

1 Spring

1.1 简介

2002年，首次提出了Spring框架的雏形：interface21框架；
Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，2004年3月24发布1.0正式版本；
Rod Johnson,Spring Framework创始人
Spring理念：使现有的技术更加容易使用，整合了现有的技术框架；
SSH:Struct2 + Spring + Hiberinate
SSM:Spring + SpringMVC +_MyBatis
官网：https://spring.io/projects/spring-framework#overview
官方下载地址：https://repo.spring.io/release/org/springframework/spring/

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.0.RELEASE</version>
</dependency>

1.2 Spring优点

Spring是一个开源的免费的框架（容器）！
Spring是一个轻量级的、非入侵式的框架！
控制反转（IOC），面向切面编程（AOP）！
支持事务的处理，对框架整合的支持！

总结一句话：Spring就是一个轻量级的控制反转（IOC）和面向切面编程（AOP）的框架！

1.2 组成

在这里插入图片描述

2.IOC理论推导

1、UserDao接口

public interface UserDao {
    void getUser();
}

2、UserDaoImpl实现类

public class UserDaoImpl implements UserDao {
    public void getUser() {
        System.out.println("默认获取用户数据");
    }
}

3、UserService接口

public interface Uservice{
	void getUser();
}

4、UserServiceImpl实现类

public class UserServiceImpl implements UserService {

    private UserDao userDao = new UserDaoImpl();

    public void getUser() {
        userDao.getUser();
    }
}

5、测试

public class MyTest {
    public static void main(String[] args) {
        //用户实际调用的是业务层，dao层他们不需要接触！
        UserService userService = new UserServiceImpl();
        userService.getUser();
    }
}

在我们之前的业务中，用户的需求可能会影响我们原来的代码，我们需要根据用户的需求去修改原代码！如果程序代码量十分大，修改一次的成本代价十分昂贵！

在这里插入图片描述
我们使用一个Set接口实现，已经发生了革命性的变化！

  private UserDao userDao;

    //利用set进行动态实现值的注入！
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

这种思想，从本质上解决了问题，我们程序猿不用再去管理对象的创建了。系统的耦合性大大降低~，可以更加专注的在业务的实现上！这是IOC的原型
在这里插入图片描述
#### IOC本质

	控制反转IOC（Inversion of Control）是一种设计思想，DI（依赖注入）是实现IOC的一种方法。没有IOC的程序中，我们使用面向对象编程，对象的创建和对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。
	采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的，而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。
	控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection，DI）。

3 HelloSpring

3.1创建maven工程，编写实体类

public class Hello {
    private String str;
    public String getStr() {
        return str;
    }
    public void setStr(String str) {
        this.str = str;
    }
    @Override
    public String toString() {
        return "Hello{" +"str='" + str + "}";
    }
}

3.2 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">


    <!--使用Spring来创建对象，在Spring这些都称为Bean
    类型 变量名 = new 类型();
    Hello hello = new Hello();

    id = 变量名
    class = new的对象
    property 相当于给对象中的属性设置一个值！
        -->
    <bean id="hello" class="com.xia.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>
</beans>

3.3 测试

public class MyTest {
    public static void main(String[] args) {
        //获取Spring的上下文对象！
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        //我们的对象现在都在Spring中的管理了，我们需要使用，直接去里面取出来就可以！
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

Hello对象由谁创建？属性如何设置？
	Hello对象由Spring创建，属性由Spring容器设置，这个过程就是控制反转。
	控制：控制对象的创建，传统应用程序的对象是由程序本身控制创建的，使用Spring后，对象由Spring容器创建。
	反转：程序本身不创建对象，而是变为被动接收对象。
	IOC是一种编程思想，由主动编程变为被动接受。
	使用了Spring，就不用了去修改程序吗，实现不同的操作，只需要在xml配置文件中进行修改，所谓的IOC，即对象由Spring创建、管理、装配。

4 IOC创建对象的方式

4.1默认使用无参构造创建对象

4.2 使用有参构造创建对象

<!--第一种方式：下标赋值    -->
<bean id="user" class="com.xia.pojo.User">
    <constructor-arg index="0" value="狂神说Java"/>
</bean>

<!--第二种方式：通过类型的创建，不建议使用    -->
<bean id="user" class="com.xia.pojo.User">
    <constructor-arg type="java.lang.String" value="lifa"/>
</bean>

<!--第三种方式：直接通过参数名来设置    -->
<bean id="user" class="com.xia.pojo.User">
    <constructor-arg name="name" value="李白"/>
</bean>

总结：在配置文件加载的时候，容器中管理的对象就已经初始化了！

5 Spring配置

5.1别名

    <!--别名，如果添加了别名，我们也可以使用别名获取到这个对象-->
    <alias name="user" alias="userNew"/>

5.2 Bean的配置

<!--
    id：bean的唯一标识符，也就是相当于我们学的对象名
    class：bean对象所对应的全限定名：包名+类名
    name：也是别名，而且name可以同时取多个别名
        -->
    <bean id="userT" class="com.xia.pojo.UserT" name="user2 u2,u3;u4">
        <property name="name" value="黑心白莲"/>
    </bean>

5.3 import

这个import。一般用于团队开发使用，它可以将多个配置文件，导入合并为一个。
假设，现在项目中有多个人开发，这三个人负责不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的！

<import resource="bean.xml"/>
<import resource="bean2.xml"/>
<import resource="bean3.xml"/>

6 依赖注入

6.1 构造器注入

6.2 set方式注入

依赖注入：Set注入
	依赖：bean对象的创建依赖于容器
	注入：bean对象中的所有属性，有容器来注入

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

测试对象

public class Student {

    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbies;
    private Map<String,String> card;
    private Set<String> games;
    private String wife;
    private Properties info;
}

beans.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">

    <bean id="student" class="com.xia.pojo.Student">
        <!--第一种：普通值注入，value        -->
        <property name="name" value="ADMIN"/>
    </bean>
</beans>

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        Student student = (Student) context.getBean("student");
        System.out.println(student.getName());
    }
}

完善注入信息

<bean id="address" class="com.xia.pojo.Address">
        <property name="address" value="西安"/>
    </bean>

    <bean id="student" class="com.xia.pojo.Student">
        <!--第一种：普通值注入，value        -->
        <property name="name" value="黑心白莲"/>

        <!--第二种：        -->
        <property name="address" ref="address"/>

        <!--数组        -->
        <property name="books">
            <array>
                <value>红楼梦</value>
                <value>西游记</value>
                <value>水浒传</value>
                <value>三国演义</value>
            </array>
        </property>

        <!--List        -->
        <property name="hobbies">
            <list>
                <value>打篮球</value>
                <value>看电影</value>
                <value>敲代码</value>
            </list>
        </property>

        <!--Map        -->
        <property name="card">
            <map>
                <entry key="身份证" value="123456789987456321"/>
                <entry key="银行卡" value="359419496419481649"/>
            </map>
        </property>

        <!--Set        -->
        <property name="games">
            <set>
                <value>LOL</value>
                <value>COC</value>
                <value>BOB</value>
            </set>
        </property>

        <!--NULL        -->
        <property name="wife">
            <null/>
        </property>

        <!--Properties        -->
        <property name="info">
            <props>
                <prop key="driver">20191029</prop>
                <prop key="url">192.168.0.110</prop>
                <prop key="user">ADMIN</prop>
                <prop key="password">123456</prop>
            </props>
        </property>

    </bean>

6.3 拓展方式注入

可以使用p命名空间和c命名空间进行注入

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

    <!--p命名空间注入，可以直接注入属性的值：property-->
    <bean id="user" class="com.xia.pojo.User" p:name="黑心白莲" p:age="20"/>

    <!--c命名空间注入，通过构造器注入：constructor-args-->
    <bean id="user2" class="com.xia.pojo.User" c:name="狂神" c:age="22"/>

</beans>

   @Test
    public void test2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");

        User user = context.getBean("user",User.class);
        System.out.println(user);

        User user2 = context.getBean("user2",User.class);
        System.out.println(user2);
    }

注意：p命名和c命名空间不能直接使用，需要导入xml约束！

6.4 bean的作用域

在这里插入图片描述

1、单例模式（spring默认机制）

<bean id="user2" class="com.xia.pojo.User" c:name="狂神" c:age="22" scope="singleton"/>

2、原型模式：每次从容器中get的时候，都会产生一个新队象

<bean id="user2" class="com.xia.pojo.User" c:name="狂神" c:age="22" scope="prototype"/>

3、其余的request、session、application、这些只能在web开发中使用到！

7. bean的自动装配

自动装配是Spring满足bean依赖的一种方式
Spring会在上下文中自动寻找，并自动给bean装配属性
Spring有3中装配方式：xml中显示配置、在java中显示配置、隐式的自动装配

7.1 测试

环境搭建，创建项目，一个人有两个宠物

  <bean id="cat" class="com.xia.pojo.Cat"/>
    <bean id="dog" class="com.xia.pojo.Dog"/>

    <bean id="people" class="com.xia.pojo.People">
        <property name="name" value="小白莲"/>
        <property name="cat" ref="cat"/>
        <property name="dog" ref="dog"/>
    </bean>

7、2 ByName自动装配

<!--
        byName：会自动在容器上下文中查找，和自己对象set方法后面的值对应的bean id！
            -->
        <bean id="people" class="com.kuang.pojo.People" autowire="byName">
            <property name="name" value="小白莲"/>
        </bean>

7.3 ByType自动装配

<!--
        byType：会自动在容器上下文中查找，和自己对象属性类型相同的bean！
            -->
        <bean id="people" class="com.kuang.pojo.People" autowire="byType">
            <property name="name" value="小白莲"/>
        </bean>

7、4 使用注解实现自动装配

java1.5支持的注解，Spring2.5就支持注解了 
导入约束，配置注解的支持

<?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
	        https://www.springframework.org/schema/beans/spring-beans.xsd
	        http://www.springframework.org/schema/context
	        https://www.springframework.org/schema/context/spring-context.xsd">
		
		<!--开启注解的支持    -->
        <context:annotation-config/>
</beans>

@Autowired
直接在属性上使用即可！也可以在set方法上使用！
使用Autowired我们就可以不用编写set方法了，前提是你这个自动配置的属性在IOC（Spring）容器中存在，且符合名字ByName！
如果@Autowired自动装配的环境比较复杂，自动装配无法通过一个注解【@Autowired】完成的时候，我们可以使用@Qualifier(value = “xxx”)去配置@Autowired的使用，指定一个唯一的bean对象注入！

public class People {
    @Autowired
    @Qualifier(value = "cat111")
    private Cat cat;
    @Autowired
    @Qualifier(value = "dog222")
    private Dog dog;
    private String name;
}

ublic class People {

    @Resource
    private Cat cat;

    @Resource
    private Dog dog;
}

@Resource和@Autowired的区别：
都是用来自动装配的，都可以放在属性字段上
@Autowired通过byType的方式实现，而且必须要求这个对象存在！【常用】
@Resource默认通过byName的方式实现，如果找不到名字，则通过byType实现！如果两个都找不到的情况下，就报错！【常用】
执行顺序不同：@Autowired通过byType的方式实现。

8、使用注解开发

在Spring4之后，要使用注解开发，必须保证aop的包导入了
使用注解需要导入context约束，增加注解的支持

<?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"
       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/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">

    <!--开启注解支持-->
    <context:annotation-config/>
    <!--指定要扫描的包，这个包下的注解就会生效-->
    <context:component-scan base-package="com.yang"/>
</beans>

8.1. bean注入使用@Componet注解

//@Component 等价于<bean id="user" class="com.yang.entity.User"/>
@Component
public class User {
    String name;
}

8.2. 属性注入使用@Value注解

//@Component 等价于<bean id="user" class="com.yang.entity.User"/>
@Component
public class User {

    String name;
    //@Value("yang") 相当于<property name="name" value="yang"/>
    @Value("yang")
    public void setName(String name) {
        this.name = name;
    }
}

8.3. 衍生注解

@Componet有几个衍生注解，我们在web开发中，会按照mvc三层架构分层！
dao层 【@Repository】
service层 【@Service】
controller层 【@Controller】
这四个注解功能都是一样的，都是代表将某个类注册到Spring中，装配Bean

8.4.自动装配

@Autowired  自动装配通过类型、名字
如果Autowired不能唯一自动装配上属性，则需要通过@Qualifier(value="xxx")
@Nullable   字段标记了这个注解，说明这个字段可以为null
@Resource 自动装配通过名字，类型

8.5. 作用域

@Scope(“singleton”)单例

8.6. 小结

XML 与 注解
xml更加万能，适用于任何场合！维护简单方便
注解不是自己类使用不了， 维护相对复杂
XML 与 注解最佳实践
xml用来管理bean
注解只负责完成属性的注入
我们在使用过程中，只需要注意一个问题：必须让注解生效，就需要开启注解的支持

<!--开启注解支持-->
   <context:annotation-config/>
   <!--指定要扫描的包，这个包下的注解就会生效-->
   <context:component-scan base-package="com.yang"/>

9、使用java的方式配置Spring

package com.xiaofan.config;

import com.xiaofan.pojo.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

/**
 * 这个也会被spring容器托管，注册到容器中，因为他本来就是一个@Component
 * @Configuration代表这是一个配置类，就和我们之前看到的beans.xml一样
 */
@Configuration
@ComponentScan("com.xiaofan.pojo")
@Import(MyConfig.class)
public class AppConfig {

    /**
     * 注册一个bean，就相当于我们之前写的一个bean标签
     * 这个方法的名字，就相当于bean标签中的id属性
     * 这个方法的返回值，就相当于bean标签中的class属性
     */

    @Bean
    public User getUser() {
        return new User();
    }

package com.yang.entity;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

@Component
public class User {

    private String name;

    public String getName() {
        return name;
    }
    @Value("Yang")
    public void setName(String name) {
        this.name = name;
    }
}

import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

//@Configuration,这个也会被Spring容器托管，注册到容器中，因为打开注解，它本身就被定义为组件了@Component
//@Configuration该注解代表了这是一个配置类，与applicationContext.xml一样
@Configuration
@ComponentScan("com.yang.entity")
@Import(YangConfig2.class)
public class YangConfig {

    //注册一个Bean，就相当于我们之前写的一个bean标签
    //方法名字 == bean标签的id
    //方法的返回值 == bean标签中的class属性

    @Bean
    public User getUser () {
        return new User();//就是返回要注入到bean的对象
    }
}

public class MyTest {

    public static void main(String[] args) {

        ApplicationContext annotationConfigApplicationContext = new AnnotationConfigApplicationContext(YangConfig.class);
        User getUser = (User)annotationConfigApplicationContext.getBean("getUser");
        System.out.println(getUser.getName());
    }
}

10、代理模式

10.1静态代理

角色分析：

抽象角色：一般会使用接口或者抽象类来解决
真实角色：被代理的角色
代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作
客户：访问代理对象的人
代码步骤：
	接口
	真实角色
	代理角色
	客户端访问代理角色
	具体代码可参考：多线程中的静态代理
代理模式的好处：
	可以使真实角色的操作更加存粹！不用去关注一些公共的业务
	公共交给了代理角色，实现了业务的分工
	公共业务发生扩展的时候，方便集中管理
缺点：
	一个真实角色就会产生一个代理角色，代码量会翻倍 开发效率变低

动态代理
动态代理和静态代理角色一样
动态代理的代理类是动态生成的，不是我们直接写好的
动态代理分为两大类：基于接口的动态代理，基于类的动态代理
基于接口：JDK动态代理
基于类： cglib
java字节码实现： javasist
需要了解两个类：Proxy：代理 InvocationHandler：调用处理程序
Proxy
	java.lang.reflect.Proxy
	Proxy提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类。(大白话：这是一个			静态类，类里边有方法得到代理类)
	动态代理类 （以下简称为代理类 ）是一个实现在类创建时在运行时指定的接口列表的类，具有如下所述的行为。 代理		接口是由代理类实现的接口。 代理实例是代理类的一个实例。 每个代理实例都有一个关联的调用处理程序对象，		它实现了接口InvocationHandler 。 通过其代理接口之一的代理实例上的方法调用将被分派到实例调用处理程序的invoke方法，传递代理实例， java.lang.reflect.Method被调用方法的java.lang.reflect.Method对象以及包含参数的类型Object Object的数组。 调用处理程序适当地处理编码方法调用，并且返回的结果将作为方法在代理实例上调用的结果返回。
代理类具有以下属性：
	代理类是公共的，最终的，而不是抽象的，如果所有代理接口都是公共的。
	如果任何代理接口是非公开的，代理类是非公开的，最终的，而不是抽象的 。
	代理类的不合格名称未指定。 然而，以字符串"$Proxy"开头的类名空间应该保留给代理类。
	一个代理类扩展了java.lang.reflect.Proxy 。
	代理类完全按照相同的顺序实现其创建时指定的接口。
	如果一个代理类实现一个非公共接口，那么它将被定义在与该接口相同的包中。 否则，代理类的包也是未指定的。 请注意，程序包密封不会阻止在运行时在特定程序包中成功定义代理类，并且类也不会由同一类加载器定义，并且与特定签名者具有相同的包。
由于代理类实现了在其创建时指定的所有接口， getInterfaces在其类对象上调用getInterfaces将返回一个包含相同列表接口的数组（按其创建时指定的顺序），在其类对象上调用getMethods将返回一个数组的方法对象，其中包括这些接口中的所有方法，并调用getMethod将在代理接口中找到可以预期的方法。
	Proxy.isProxyClass方法将返回true，如果它通过代理类 - 由Proxy.getProxyClass返回的类或由Proxy.newProxyInstance返回的对象的类 - 否则为false。
	所述java.security.ProtectionDomain代理类的是相同由引导类装载程序装载系统类，如java.lang.Object ，因为是由受信任的系统代码生成代理类的代码。 此保护域通常将被授予java.security.AllPermission 。
	每个代理类有一个公共构造一个参数，该接口的实现InvocationHandler ，设置调用处理程序的代理实例。 而不必使用反射API来访问公共构造函数，也可以通过调用Proxy.newProxyInstance方法来创建代理实例，该方法将调用Proxy.getProxyClass的操作与调用处理程序一起调用构造函数。

//为某个接口创建代理Foo ： 
  InvocationHandler handler = new MyInvocationHandler(...);
     Class<?> proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), Foo.class);
     Foo f = (Foo) proxyClass.getConstructor(InvocationHandler.class).
                     newInstance(handler); 
  //或更简单地： 
  Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
                                          new Class<?>[] { Foo.class },
                                          handler);

public static 类<?> getProxyClass(ClassLoader loader,
                                     类<?>... interfaces)
                              throws IllegalArgumentException
/*给定类加载器和接口数组的代理类的java.lang.Class对象。 代理类将由指定的类加载器定义，并将实现所有提供的接口。 如果任何给定的接口是非公开的，则代理类将是非公开的。 如果类加载器已经定义了接口相同置换的代理类，那么将返回现有的代理类; 否则，这些接口的代理类将被动态生成并由类加载器定义。 
对可能传递给Proxy.getProxyClass的参数有几个Proxy.getProxyClass ： 

interfaces数组中的所有类对象都必须表示接口，而不是类或原始类型。 
interfaces数组中没有两个元素可能是指相同的类对象。 
所有的接口类型必须通过指定的类加载器的名称可见。 换句话说，对于类加载器cl和每个接口i ，以下表达式必须为真： 
  Class.forName(i.getName(), false, cl) == i 所有非公共接口必须在同一个包中; 否则代理类将不可能实现所有接口，而不管其中定义了什么包。 
对于具有相同签名的指定接口的任何成员方法集合： 
如果任何方法的返回类型是原始类型或void，则所有方法必须具有相同的返回类型。 
否则，其中一个方法必须具有一个返回类型，该类型可以分配给其余方法的所有返回类型。 
生成的代理类不能超过虚拟机对类施加的任何限制。 例如，VM可以将类可以实现的接口数量限制为65535; 在这种情况下， interfaces阵列的大小不得超过65535。 
如果任何这些限制被违反， Proxy.getProxyClass将抛出一个IllegalArgumentException 。 如果interfaces数组参数或其任何元素为null ，则将抛出一个NullPointerException 。 

请注意，指定的代理接口的顺序是重要的：具有相同组合的接口但不同顺序的代理类的两个请求将导致两个不同的代理类。 

参数 
loader - 类加载器来定义代理类 
interfaces - 要实现的代理类的接口列表 
结果 在指定的类加载器中定义并实现指定接口的代理类 */

public static Object newProxyInstance(ClassLoader loader,
                                      类<?>[] interfaces,
                                      InvocationHandler h)
                               throws IllegalArgumentException
/*返回指定接口的代理类的实例，该接口将方法调用分派给指定的调用处理程序。 
Proxy.newProxyInstance因为与IllegalArgumentException相同的原因而Proxy.getProxyClass 。 

参数 
loader - 类加载器来定义代理类 
interfaces - 代理类实现的接口列表 
h - 调度方法调用的调用处理函数 
结果 
具有由指定的类加载器定义并实现指定接口的代理类的指定调用处理程序的代理实例 */

InvocationHandler

InvocationHandler是由代理实例的调用处理程序实现的接口 。
	每个代理实例都有一个关联的调用处理程序。 当在代理实例上调用方法时，方法调用将被编码并分派到其调用处理程序的invoke方法。
	invoke(Object proxy, 方法 method, Object[] args) 处理代理实例上的方法调用并返回结果。

Object invoke(Object proxy,
              方法 method,
              Object[] args)
       throws Throwable处理代理实例上的方法调用并返回结果。 当在与之关联的代理实例上调用方法时，将在调用处理程序中调用此方法。 
/*参数 
proxy - 调用该方法的代理实例 
method -所述方法对应于调用代理实例上的接口方法的实例。 方法对象的声明类将是该方法声明的接口，它可以是代理类继承该方法的代理接口的超级接口。 
args -包含的方法调用传递代理实例的参数值的对象的阵列，或null如果接口方法没有参数。 原始类型的参数包含在适当的原始包装器类的实例中，例如java.lang.Integer或java.lang.Boolean 。 
结果 
从代理实例上的方法调用返回的值。 如果接口方法的声明返回类型是原始类型，则此方法返回的值必须是对应的基本包装类的实例; 否则，它必须是可声明返回类型的类型。 如果此方法返回的值是null和接口方法的返回类型是基本类型，那么NullPointerException将由代理实例的方法调用抛出。 如上所述，如果此方法返回的值，否则不会与接口方法的声明的返回类型兼容，一个ClassCastException将代理实例的方法调用将抛出。 
异常 
Throwable - 从代理实例上的方法调用抛出的异常。 异常类型必须可以分配给接口方法的throws子句中声明的任何异常类型java.lang.RuntimeException检查的异常类型java.lang.RuntimeException或java.lang.Error 。 如果检查的异常是由这种方法是不分配给任何的中声明的异常类型throws接口方法的子句，则一个UndeclaredThrowableException包含有由该方法抛出的异常将通过在方法调用抛出代理实例。 */

package com.yang.demo;
public interface UserServiceInterface {
    public void add();
    public void delete();
    public void update();
    public void select();
}

package com.yang.demo;
public class UserServiceImpl implements UserServiceInterface{
    public void add() {
        System.out.println("增加一个用户");
    }
    public void delete() {
        System.out.println("删除一个用户");
    }
    public void update() {
        System.out.println("更新一个用户");
    }
    public void select() {
        System.out.println("检索一个用户");
    }
}

package com.yang.demo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//自动生成代理类的类
public class ProxyInvocationHandler implements InvocationHandler {

    //被代理的接口
    private Object target;

    public void setTarget (Object target) {
        this.target = target;
    }
    //重写的InvocationHandler中的invoke方法
    //处理代理实例，并返回结果
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        Object invoke = method.invoke(target, args);
        return invoke;
    }
    //生成得到代理类
    public Object getProxy () {
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(), this);
    }
    public void log (String msg) {
        System.out.println("执行了" + msg + "方法");
    }
}

package com.yang.demo;

public class Client {
    public static void main(String[] args) {
        //真实角色
        UserServiceImpl userService = new UserServiceImpl();
        //代理角色，不存在
        ProxyInvocationHandler proxyInvocationHandler = new ProxyInvocationHandler();
        //设置要代理的对象
        proxyInvocationHandler.setTarget(userService);
        //注意要用接口强转，否则会报异常
        UserServiceInterface proxy = (UserServiceInterface)proxyInvocationHandler.getProxy();
        proxy.add();
    }
}

11、AOP

在这里插入图片描述

1.2 Aop在Spring中的作用

提供生命事务：允许用户自定义切面

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

在这里插入图片描述

11.3 使用Spring实现AOP

【重点】使用AOP织入，需要依赖包

<dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
</dependency>

方式一：使用Spring的API接口
eg:在执行UserService实现类的所有方法时，增加日志功能

package com.yang.service;
public interface UserService {
    public void add();
    public void update();
    public void delete();
    public void select();
}

package com.yang.service;
public class UserServiceImpl implements UserService{
    public void add() {
        System.out.println("增加了一个用户");
    }
    public void update() {
        System.out.println("更新了一个用户");
    }
    public void delete() {
        System.out.println("删除了一个用户");
    }
    public void select() {
        System.out.println("检索了一个用户");
    }
}

import org.springframework.aop.AfterReturningAdvice;
import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;
public class Log implements MethodBeforeAdvice, AfterReturningAdvice {
    //method:要执行的目标对象的方法（method being invoked）
    //object:参数（args: arguments to the method）
    //o:目标对象 （target：target of the method invocation）
    public void before(Method method, Object[] args, Object target) throws Throwable {
        System.out.println(target.getClass().getName() + "的" + method.getName() + "被执行了");
    }
    //returnValue:返回值
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("执行了" + method.getName() + "方法，返回值为" + returnValue);
    }
}

/**配置文件*/
<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--注册bean-->
    <bean id="userService" class="com.yang.service.UserServiceImpl"/>
    <bean id="log" class="com.yang.log.Log"/>
    <!--方式：使用原生Spring Api接口-->
    <!--配置aop-->
    <aop:config>
        <!--切入点：execution:表达式，execution(*(修饰词) *(返回值) *(类名) *(方法名) *(参数))  ..任意参数-->
        <aop:pointcut id="pointcut" expression="execution(* com.yang.service.UserServiceImpl.*(..))"/>

        <!--执行环绕增加-->
        <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
    </aop:config>
</beans>


import com.yang.service.UserService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MyTest {
    public static void main(String[] args) {
        ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserService userService = classPathXmlApplicationContext.getBean("userService", UserService.class);
        userService.add();
    }
}

方式二：自定义来实现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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--注册bean-->
    <bean id="userService" class="com.yang.service.UserServiceImpl"/>
    <bean id="log" class="com.yang.log.Log"/>
    <bean id="diy" class="com.yang.diy.DiyPointCut"/>
    <!--方式2：自定义类-->
    <aop:config>
    	<!--<aop:aspect ref="diy"> : 标注这个类为切面-->
        <aop:aspect ref="diy">
            <!--切入点-->
            <aop:pointcut id="point" expression="execution(* com.yang.service.UserServiceImpl.*(..))"/>
            <!--通知-->
            <aop:before method="beforeMethod" pointcut-ref="point"/>
        </aop:aspect>
    </aop:config>
</beans>

/**自定义类*/
package com.yang.diy;
public class DiyPointCut {
    public void beforeMethod () {
        System.out.println("方法执行之前");
    }
}

方式三：使用注解实现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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">

    <!--注册bean-->
    <bean id="userService" class="com.yang.service.UserServiceImpl"/>
    <!--方式3：使用注解-->
    <!--开启注解支持  JDK（默认proxy-target-class="false"）cglib默认proxy-target-class="true"）-->
    <aop:aspectj-autoproxy proxy-target-class="false"/>
    <bean id="annotationPointCut" class="com.yang.diy.AnnotationPointcut"/>
<beans/>

package com.yang.diy;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AnnotationPointcut {
    @Before("execution(* com.yang.service.UserServiceImpl.*(..))")
    public void before () {
        System.out.println("====方法执行前====");
    }
    @After("execution(* com.yang.service.UserServiceImpl.*(..))")
    public void after () {
        System.out.println("====方法执行后====");
    }
    //在环绕增强中，我们可以给定一个参数，代表我们要获取处理切入的点
    @Around("execution(* com.yang.service.UserServiceImpl.*(..))")
    public void around (ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕前");
        Signature signature = pjp.getSignature();//获得签名
        System.out.println("signature" + signature);

        Object proceed = pjp.proceed();//执行方法
        System.out.println("环绕后");
    }
}

12、整合MyBatis

12.1方式一：

导入相关jar包
junit	mybatis	mysql数据库	spring相关的	aop织入	mybatis-spring

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>spring-study</artifactId>
        <groupId>com.yang</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>spring-10-mybatis</artifactId>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.2</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.0.RELEASE</version>
        </dependency>
        <!--Spring操作数据库的话，还需要一个spring-jdbc-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>1.8.13</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.2</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.10</version>
        </dependency>
    </dependencies>

    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>
</project>

编写配置文件
spring-dao.xml配置数据源DataSource与sqlSession

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--DataSource：使用Spring的数据源替换Mybatis的配置  c3p0  dbcp  druid
    我们这里使用Spring提供的JDBC：org.springframework.jdbc.datasource-->
    <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?useSSL=true&amp;useUnicode=false&amp;characterEncoding=utf-8"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </bean>
    <!--sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <!--绑定Mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        <property name="mapperLocations" value="classpath:com/yang/mapper/*.xml"/>
    </bean>

    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <!--只能使用构造器注入sqlSessionFactory，因为没有set方法-->
        <constructor-arg index="0" ref="sqlSessionFactory"/>
    </bean>
</beans>

mybatis-config.xml配置一些mybatis专属配置

<?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>
    <typeAliases>
        <package name="com.yang.entity"/>
    </typeAliases>
</configuration>

applicationContext.xml整合与注册bean等

<?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
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        https://www.springframework.org/schema/aop/spring-aop.xsd">
    <import resource="spring-dao.xml"/>
    <bean id="userMapper" class="com.yang.mapper.UserMapperImpl">
        <property name="sqlSessionTemplate" ref="sqlSession"/>
    </bean>
</beans>

package com.yang.entity;
import lombok.Data;
@Data
public class User {
    private int id;
    private String name;
    private int pwd;
}

package com.yang.mapper;
import com.yang.entity.User;
import java.util.List;

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

package com.yang.mapper;

import com.yang.entity.User;
import org.mybatis.spring.SqlSessionTemplate;

import java.util.List;

public class UserMapperImpl implements UserMapper{

    //我们的所有操作，原来都是用sqlSession来执行，现在都是用sqlSessionTemplate
    private SqlSessionTemplate sqlSessionTemplate;

    public void setSqlSessionTemplate (SqlSessionTemplate sqlSessionTemplate) {
        this.sqlSessionTemplate = sqlSessionTemplate;
    }
    public List<User> selectUser() {
        UserMapper mapper = sqlSessionTemplate.getMapper(UserMapper.class);
        return mapper.selectUser();
    }
}

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.yang.mapper.UserMapper">
    <select id="selectUser" resultType="user">
        select * from mybatis.user;
    </select>
</mapper>

import com.yang.entity.User;
import com.yang.mapper.UserMapper;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

public class MyTest {
    @Test
    public void test () throws IOException {
        ApplicationContext classPathXmlApplicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");

        UserMapper userMapper = classPathXmlApplicationContext.getBean("userMapper", UserMapper.class);
        List<User> userList = userMapper.selectUser();

        for (User user : userList) {
            System.out.println(user);
        }
    }
}

12.2 方式二

SqlSessionDaoSupport
SqlSessionDaoSupport 是一个抽象的支持类，用来为你提供 SqlSession。调用 getSqlSession() 方法你会得到一个 SqlSessionTemplate，之后可以用于执行 SQL 方法，就像下面这样:

package com.yang.mapper;

import com.yang.entity.User;
import org.apache.ibatis.session.SqlSession;
import org.mybatis.spring.support.SqlSessionDaoSupport;

import java.util.List;
public class UserMapperImpl2 extends SqlSessionDaoSupport implements UserMapper {
    public List<User> selectUser() {
        SqlSession sqlSession = getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> users = mapper.selectUser();
        //return getSqlSession().getMapper(UserMapper.class).selectUser();
        return users;
    }
}

实际上是整合mybatis一与整合mybatis二是一样的方法，只不过二继承了SqlSessionDaoSupport ，在getSqlSession()，做的也是setSqlSessionTemplate
![在这里插入图片描述](https://img-blog.csdnimg.cn/20210331112802482.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTc2ODIyMw==,size_16,color_FFFFFF,t_70#pic_center)

13.Spring配置声明式事务注入

13.1 事务回顾

把一组业务当做一个业务来做，要么都成功，要么都失败；
事务在项目开发中，十分重要，涉及到数据一致性的问题
完整性和一致性
事务ACID原则：
原子性
一致性
隔离性：多个业务可能操作同一个资源，防止数据损坏
持久性：事务一旦提交，无论发生什么，结果都不再被影响，被持久化的写入到存储器中

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

    <import resource="spring-dao.xml"/>

    <bean id="userMapper" class="com.yang.mapper.UserMapperImpl2">
        <property name="sqlSessionTemplate" ref="sqlSession"/>
    </bean>
    <!--配置声明事务注入-->
    <!--要开启 Spring 的事务处理功能，在 Spring 的配置文件中创建一个 DataSourceTransactionManager 对象：-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
        <!--或者使用构造注入-->
        <!--<constructor-arg ref="dataSource" />-->
    </bean>

    <!--结合AOP实现事务的织入-->
    <!--配置事务通知-->
    <tx:advice id="txAdvice" transaction-manager="transactionManager">
        <!--给哪些方法配置事务-->
        <!--配置事务的传播特性 propagation
                PROPAGATION_REQUIRED:如果当前没有事务，就新建一个事务，如果已存在一个事务中，加入到这个事务中，这是最常见的选择。
                PROPAGATION_SUPPORTS:支持当前事务，如果没有当前事务，就以非事务方法执行。
                PROPAGATION_MANDATORY:使用当前事务，如果没有当前事务，就抛出异常。
                PROPAGATION_REQUIRES_NEW:新建事务，如果当前存在事务，把当前事务挂起。
                PROPAGATION_NOT_SUPPORTED:以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
                PROPAGATION_NEVER:以非事务方式执行操作，如果当前事务存在则抛出异常。
                PROPAGATION_NESTED:	如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED 类似的操作
        -->
        <tx:attributes>
            <tx:method name="add" propagation="REQUIRED"/>
            <tx:method name="delete" propagation="REQUIRED"/>
            <tx:method name="update" propagation="REQUIRED"/>
            <tx:method name="select" read-only="true"/>
            <!--全部方法-->
            <tx:method name="*" propagation="REQUIRED"/>
        </tx:attributes>
    </tx:advice>

    <!--配置事务切入-->
    <aop:config>
    	<!--该包下的所有方法-->
        <aop:pointcut id="txPointCut" expression="execution(* com.yang.mapper.*.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="txPointCut"/>
    </aop:config>
</beans>

夏沫y

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Spring学习笔记

Spring1.1 简介2002年，首次提出了Spring框架的雏形：interface21框架；Spring框架即以interface21框架为基础，经过重新设计，并不断丰富其内涵，2004年3月24发布1.0正式版本；Rod Johnson,Spring Framework创始人，著名作者，悉尼大学博士，专业是音乐学而非计算机；Spring理念：使现有的技术更加容易使用，本身是一个大杂烩，整合了现有的技术框架；SSH:Struct2 + Spring + HiberinateSSM:Spr
复制链接

扫一扫