Spring 框架的使用 1

最新推荐文章于 2022-04-25 14:32:45 发布
最新推荐文章于 2022-04-25 14:32:45 发布
阅读量86 收藏
点赞数
分类专栏： Java 相关 文章标签： java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liu1shi/article/details/112971321
版权

在这里插入图片描述

  Spring 是一个项目管理框架，简化企业级开发，俗称”胶水框架”。

  自定义工厂类做类的实例化。


// mypro.properties
userdao=com.baidu.day.text.dao.impl.UserDaoImpl

// MyUtils.java
public class MyUtils {

    public static Properties properties = null;

    static {
        InputStream resourceAsStream = MyUtils.class.getClassLoader().getResourceAsStream("mypro.properties");
        properties = new Properties();
        try {
            properties.load(resourceAsStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public static Object getObject(String beanName) {
        String property = properties.getProperty(beanName);
        try {
            Class<?> aClass = Class.forName(property);
            return aClass.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}

// IUserDao.java
public interface IUserDao {
    void show();
}

// UserDaoImpl.java
public class UserDaoImpl implements IUserDao {
    @Override
    public void show() {
        System.out.println("hello spring。");
    }
}

// 测试
IUserDao userDao = (UserDaoImpl)MyUtils.getObject("userdao");
        userDao.show();

  使用 Spring 做类的实例化。
  Spring 工厂特性。饿汉式创建。工厂创建之后，会将 Spring 配置文件中的所有对象都创建完成（饿汉式）。提高程序运行效率。避免多次IO，减少对象创建时间。（概念接近连接池，一次性创建好，使用时直接获取）。


// pom.xml

<dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.2.12.RELEASE</version>
    </dependency>
    
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.16</version>
    </dependency>
  </dependencies>


// spring.xml

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

    <bean id="userDao" class="com.baidu.day.text.dao.impl.UserDaoImpl" />

</beans>



// 测试
 ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        IUserDao userDao = (IUserDao) ac.getBean("userDao");
        userDao.show();

  IDEA 添加代码模版。
  Preferences -> Editor -> File And Code Templates。

  单例和多例。

// spring.xml
<!--  scope="prototype" 多例，默认为单例 singleton -->
    <bean id="userDao" class="com.baidu.day.text.dao.impl.UserDaoImpl" scope="prototype" />


// 测试
ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
IUserDao userDao1 = (IUserDao) ac.getBean("userDao");
IUserDao userDao2 = (IUserDao) ac.getBean("userDao");
IUserDao userDao3 = (IUserDao) ac.getBean("userDao");

System.out.println(userDao1);
System.out.println(userDao2);
System.out.println(userDao3);

  控制反转。实际上是类的嵌套实例化。


// IUserService.java

public interface IUserService {
    void show();
}

// UserServiceImpl.java 
// 注意要写set/get
@Data
public class UserServiceImpl implements IUserService {
    private IUserDao userDao;
    @Override
    public void show() {

        userDao.show();
        System.out.println("这是 service");
    }
}

// spring.xml

<bean id="userDao" class="com.baidu.day.text.dao.impl.UserDaoImpl" scope="prototype" />

// 1
    <bean id="userService" class="com.baidu.day.text.service.impl.UserServiceImpl" >
<!--      name 对应实例属性名; ref，引用，对应实例的bean id  -->
        <property name="userDao" ref="userdao"></property>
    </bean>

// 2、3
<!--   autowire 自动写入。byName，根据属性名，引入的bean id 和 属性名要一致；byType，根据属性类型 -->
    <bean id="userService" class="com.baidu.day.text.service.impl.UserServiceImpl" autowire="byName">

    </bean>

// 测试
		ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        IUserService userService = (IUserService) ac.getBean("userService");
        userService.show();

  依赖注入。实际上就是初始化赋值。


@Data
public class Address {

    private Integer id;
    private String address;

}


// User.java

@Data
public class User {

    private Integer id;
    private String password;
    private String sex;
    private Integer age;

    private Date bornDate;
    private String[] hobbys;
    private Set<String> phones;
    private List<String> names;
    private Map<String,String> countries;
    private Properties files;
    /* 对象s */
    private Address address;

}



// spring.xml 部分代码

<!--  依赖注入   -->
    <bean id="user" class="com.baidu.day.text.entity.User">
<!--    使用set、get方法赋值    -->
        <property name="id" value="1"></property>
        <property name="password" value="123"></property>
        <property name="sex" value="男"></property>
        <property name="age" value="12"></property>

<!--     日期, 固定格式 xxxx/xx/xx -->
        <property name="bornDate" value="2021/1/21"></property>

<!--        数组 -->
        <property name="hobbys">
            <array>
                <value>coding</value>
                <value>read</value>
                <value>write</value>
            </array>
        </property>

<!--        set -->
        <property name="phones">
            <set>
                <value>123</value>
                <value>234</value>
            </set>
        </property>

<!--       list -->
        <property name="names">
            <list>
                <value>admin</value>
                <value>张三</value>
            </list>
        </property>

<!--        map -->
        <property name="countries">
            <map>
                <entry key="cn">
                    <value>china</value>
                </entry>
                <entry key="usa">
                    <value>amarican</value>
                </entry>
            </map>
        </property>

<!--        properties -->
        <property name="files">
            <props>
                <prop key="username">admin</prop>
                <prop key="password">123</prop>
            </props>
        </property>

        <!--    对象 -->
        <property name="address">
            <bean class="com.baidu.day.text.entity.Address">
                <property name="id" value="1"></property>
                <property name="address" value="北京"></property>
            </bean>
        </property>
    </bean>



// 测试
		ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        User user = (User) ac.getBean("user");
        System.out.println(user);

  构造注入。


// Student.java
public class Student {

    private Integer id;
    private String name;
    private String sex;
    private Integer age;

    public Student(Integer id, String name, String sex, Integer age) {
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.age = age;
    }
}

// spring.xml
<!--   默认调用无参构造方法，没有会报错 -->
    <bean id="student" class="com.baidu.day.text.entity.Student">

<!--        根据参数名 -->
        <constructor-arg name="id" value="1"></constructor-arg>
        <constructor-arg name="name" value="admin"></constructor-arg>
        <constructor-arg name="sex" value="男"></constructor-arg>
        <constructor-arg name="age" value="12"></constructor-arg>

<!--       根据下标 -->
<!--        <constructor-arg index="0" value="1"></constructor-arg>-->
<!--        <constructor-arg index="1" value="admin"></constructor-arg>-->
<!--        <constructor-arg index="2" value="男"></constructor-arg>-->
<!--        <constructor-arg index="3" value="12"></constructor-arg>-->

<!--       根据参数个数 -->
<!--        <constructor-arg value="1"></constructor-arg>-->
<!--        <constructor-arg value="admin"></constructor-arg>-->
<!--        <constructor-arg value="男"></constructor-arg>-->
<!--        <constructor-arg value="12"></constructor-arg>-->

    </bean>

  对象初始化和销毁。


// Address.java

@Data
public class Address {
    private Integer id;
    private String address;
    
    public void init(){
        System.out.println("初始化了");
    }

    public void destroy(){
        System.out.println("销毁");
    }
}

// spring.xml
	<bean id="address" class="com.baidu.day.text.entity.Address" init-method="init" destroy-method="destroy">
        <property name="id" value="1"></property>
        <property name="address" value="深圳"></property>
    </bean>

  FactoryBean 创建复杂对象。


// MyConnection.java

public class MyConnection implements FactoryBean<Connection> {


    @Override
    public Connection getObject() throws Exception {

        Class.forName("com.mysql.jdbc.Driver");
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb1", "admin", "admin");
        return connection;
    }

    @Override
    public Class<?> getObjectType() {
        return Connection.class;
    }

    // 是否单例
    @Override
    public boolean isSingleton() {
        return false;
    }
}


// spring.xml
<!--  返回的是 getObject 返回的  -->
    <bean id="conn" class="com.baidu.day.text.utils.MyConnection"></bean>

// 测试
		ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");
        Connection connection = (Connection) ac.getBean("conn");
        System.out.println(connection);

  代理。就是找个中间人来做事。常用来回调数据。

  静态代理。

// IFangDong.java
public interface IFangDong {
    void zufang();
}

// FangDongImpl.java
public class FangDongImpl implements IFangDong {


    @Override
    public void zufang() {
        System.out.println("租房");
        System.out.println("收钱");
    }
}

// ZuFangProxy.java 
// 代理
@Data
public class ZuFangProxy {

    private IFangDong fangDong = new FangDongImpl();

    public void zufang() {
        System.out.println("发布信息");
        System.out.println("找人看房");

        //
        fangDong.zufang();
    }
}

// 测试
ZuFangProxy z = new ZuFangProxy();
z.zufang();

  动态代理。


// DynamicProxy.java

public class DynamicProxy {

    public static void jdk() {
        // 主要对有实现接口的实现类进行动态代理的生成

        final FangDongImpl fangDong = new FangDongImpl();

        // 设置代理
        InvocationHandler in = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

                System.out.println("发布信息");
                System.out.println("找人看房");
                fangDong.zufang();
                return null;
            }
        };

        // 生成代理类
        IFangDong o = (IFangDong) Proxy.newProxyInstance(DynamicProxy.class.getClassLoader(), fangDong.getClass().getInterfaces(), in);
        o.zufang();
        System.out.println(o.getClass());
    }

    public static void cglib() {
        // 主要应用于没有实现接口的类，进行动态代理的生成
        final FangDongImpl fangDong = new FangDongImpl();

        Enhancer en = new Enhancer();

        en.setSuperclass(FangDongImpl.class);

        // 设置代理
        en.setCallback(new org.springframework.cglib.proxy.InvocationHandler() {
            @Override
            public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
                System.out.println("发布信息");
                System.out.println("找人看房");
                fangDong.zufang();
                return null;
            }
        });

        // 生成代理类
        IFangDong o = (IFangDong) en.create();
        o.zufang();
        System.out.println(o.getClass());
    }

    public static void main(String[] args) {
        jdk();

        cglib();
    }

}

  AOP，Aspect Oriented Programming，面向切面编程。


// pom.xml 添加

<dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>5.1.16.RELEASE</version>
</dependency>



// MyBefore.java 

public class MyBefore implements MethodBeforeAdvice {
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println("这个是aop前置增强");
        System.out.println("写日志");
    }
}



// spring.xml 部分代码 ，相关的类在上面例子中有
<!-- aop -->
    <bean id="fangdong" class="com.baidu.day.text.proxy.FangDongImpl"></bean>
    <bean id="zufangproxy" class="com.baidu.day.text.proxy.ZuFangProxy">
    <!-- 有属性的引入一定要写 set/get -->
       <property name="fangDong" ref="fangdong"></property>
    </bean>
<!--  声明增强类  -->
    <bean id="mybefore" class="com.baidu.day.text.advice.MyBefore"></bean>

    <aop:config>
    	// 设置切点。zufang 所有同名方法都会走。
        <aop:pointcut id="myPointcut" expression="execution(* zufang(..))"/>
        <aop:advisor advice-ref="mybefore" pointcut-ref="myPointcut"></aop:advisor>
    </aop:config>

</beans>



// 测试
		ApplicationContext ac = new ClassPathXmlApplicationContext("spring.xml");

		ZuFangProxy proxy = (ZuFangProxy)ac.getBean("zufangproxy");
		// class com.baidu.day.text.proxy.ZuFangProxy , proxy说明是代理类
        System.out.println(proxy.getClass());
        proxy.zufang();

// 打印，前置打印了两次，是因为zufang 方法名匹配到两次的原因
class com.baidu.day.text.proxy.ZuFangProxy$$EnhancerBySpringCGLIB$$e1f1afde

这个是aop前置增强
写日志
发布信息
找人看房
这个是aop前置增强
写日志
租房
收钱
放气
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
Spring框架介绍及使用
qq_22583741的博客
03-17 38万+
Spring框架—控制反转（IOC） 1 Spring框架概述 1.1 什么是Spring 1.2 Spring的优点 1.3 Spring的体系结构 2 入门案例:（IoC） 2.1导入jar包 2.2目标类 2.3 配置文件 2.4测试 3 入门案例：DI 3.1 目标类 3.2 dao 3.3 service 3.4 配置文件 3.5 测试 4 依赖注入...
Spring框架从入门到精通
cgblpx的博客
06-08 3万+
初识Spring框架 时代变迁 原始时代我们用一个jsp搞定一切，但如此开发大型项目时我们遇到了问题，前端美化的代码和后端的代码交织，代码中又有html、js、css样式，又有业务逻辑和数据库访问代码，杂乱不清晰，美工和开发打架。 于是mvc分层架构封建时代出现，把我们写代码的地方硬性分成3个地方，Model层封装数据，View视图层页面展现，Controller控制层访问转发。代码之间的耦合度降低。概念有了，需要实际干活的。于是随着mvc分层概念的深入人心，业界涌现出很多实现框架，最著名的莫过于strut
Spring框架
m0_51457307的博客
11-20 1万+
一、Spring概述 Spring 是目前主流的 Java Web 开发框架，是 Java 世界最为成功的框架。该框架是一个轻量级的开源框架，具有很高的凝聚力#%E4%B8%80%E3%80%81Spring%E6%A6%82%E8%BF%B0和吸引力。
Spring框架学习心得(1)
Overlay762的博客
11-10 4万+
Spring <dependencies> <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-webmvc</artifactId>
Spring框架详解
热门推荐
m0_63324772的博客
04-12 5万+
Spring框架详解（五万字）入门级 简介Spring5框架 内容介绍： 1.Spring概念 2.IOC容器 3.Aop 4.JDBCTEmplate 5.事物管理 6.Spring5新特性
spring框架特点
weixin_57176230的博客
04-25 6041
框架特点 1.方便解耦、简化开发 通过Spring提供的IoC容器，我们可以将对象之间的依赖关系交由Spring进行控制，避免硬编码所造 成的过度程序耦合。有了Spring，用户不必再为单实例模式类、属性文件解析等这些很底层的需求编写 代码，可以更专注于上层的应用。 2.AOP编程支持 通过Spring提供的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通 过AOP轻松应付。 3.声明式事务的支持 在Spring中，我们可以...
Spring框架搭建
znnzuishuai的博客
03-26 1650
Spring框架搭建 Spring有以下几个优点： 1.Spring是一个开源免费的框架（容器） 2.Spring是一个轻量级的、非入侵式的框架 3.控制反转（IOC） 4.面向切面编程（AOP） 5.支持事务的处理，对框架整合的支持 IOC： 轻耦合 ...
Spring框架简单介绍
qq_61353850的博客
04-19 2501
1、Spring框架的概述： Spring是一个开源代码的设计层面框架，解决的是业务逻辑和其他各层次的松耦合问题，主要的思想是面向接口编程。 Spring的核心是控制权反转（IOC）和面向切面（AOP），Spring是一个分层的JavaSE/EEfull-stack（一站式）轻量级开源框架 IOC:控制权反转，将创建对象的过程交给Spring进行管理 AOP：面向切面，在不修改源代码的情况下进行代码功能的增强 2、Spring的优点 方便解耦，简化开发，Spring是一个大工厂，可以将所有对象的
Spring 框架基本使用（详细）
ONESTARの博客
09-21 2万+
目录 一、Spring 概述 1、简介 2、搭建 Spring IOC环境 二、Spring对Bean的管理 1、创建bean的方式 2、获取bean的方式 3、bean 对象的生命周期 4、bean 的作用范围 三、Spring 的依赖注入 1、构造函数注入 2、set 注入 3、集合注入 四、Spring 注解配置 1、创建Spring配置文件 2、注解配置 3...
使用Spring框架的优点有哪些？
技术专家
03-25 1924
使用Spring框架的优点有哪些？ Spring是java企业级应用的开源开发框架，主要用来开发Java应用，但有些扩展是针对构建J2EE平台的web应用。Spring框架目标是简化Java企业级应用开发，并通过POJO为基础的编程模型促进良好的编程习惯。Spring最核心的两个点就是IOC和AOP。 使用Spring框架的优点 Spring具有简单、可测试和松耦合等特点，从这个角度出发，Spring不仅可以用于服务器端开发，也可以应用于任何Java应用的开发中，Spring框架优点总结： 1、非侵入式设
spring框架学习1
最新发布
08-08
1. Spring框架的核心特性： - IoC容器：IoC是Spring的核心，它负责管理和组装应用程序中的对象。BeanFactory是IoC容器的基础接口，它能根据配置信息实例化、定位和配置应用程序对象。XMLBeanFactory是BeanFactory的...
spring框架2016
08-26
最新spring框架2016视频教程，包含源码和笔记。小白入手实用教程。
使用Spring2.5TestContext测试框架
03-03
本文内容包括： 概述直接使用JUnit测试Spring程序存在的不足一个需要测试的Spring服务类编写UserService的测试用例准备测试数据并检测运行结果SpringTestContext测试框架体系结构小结参考资料Spring2.5TestContext...
mac 下 java jdk 下载
liu1shi的博客
11-06 2984
mac 下 java jdk 下载 黎昏   啊哈，开篇。   我当日记写的，不过我中学的日记里每天在扶不同的老奶奶过马路，也是相当的辛苦，所以就不讲什么行文规范和语言组织了。   我用的系统是 Mac OS，java 官方????，选择版本下载安装后。   点击桌面空白，左上角 > 前往 > 前往文件夹 > /Library/Java，找到 JavaVirtualMachines/jdk1.8.0_271.jdk/Contents/Home。   终端里 cd ，然后拖动 Home
mac 下 linux 虚拟机的简单安装和使用
liu1shi的博客
02-04 1591
  下载VMware Fusion（链接，https://www.vmware.com/）。   下载 linux 虚拟机的镜像 CentOS-7.iso，下载简版的就行。   将 CentOS-7.iso 拖到 VMware 里安装，要求至少预留20G 硬盘空间，安装时可以选择安装到移动硬盘上。注意安装时要选择中文语言、打开以太网络和设置密码。   使用终端连接虚拟机。 // linux 下， 查询 linux ip ip a // mac 下，右键终端 -> 新建远程连接，然后可以在终端..
mac 下使用 sublime 编译并执行 java 代码
liu1shi的博客
11-06 1512
  我一直用的开发工具是 xcode 和 sublime，就想用 sublime 开发 java。   sublime 是功能强大的文本编辑器和代码编辑器，有丰富的插件以支持各种语言的开发。   用 sublime 编译并执行 java 代码，需要修改 Javac.sublime-build 文件。为了修改这个文件，耗费我大半功夫。   安装 sublime text 3 后，安装 Package Control，命令安装方法，sublime 内，control + ～，粘贴 python 代码并执行。..
Mac 下 Maven 的配置和使用
liu1shi的博客
01-13 1072
  Maven 是纯 java 开发的开源的项目管理工具。进行依赖管理 (jar 包依赖管理) 和项目构建 (项目编译、打包、测试、部署)。此外还能分块开发，提高开发效率。   Maven 下载。   （链接 ，http://apache.org/），Project List 找到 Maven，左列表 Download -> Binary zip archive。   解压 -> 改名 Maven -> 拖到 /library 目录下。   Maven 环境变量。   $ source..
jsp 实现文件上传和下载
liu1shi的博客
12-30 1047
  文件上传。   需要注意。   form 表单要设置属性 enctype=“multipart/form-data”。   文件名要用 UUID.randomUUID() 重组，否则相同文件名会覆盖。UUID.randomUUID() 每次取值不同且唯一。   文件过多不容易管理，需要用未 UUID.randomUUID() 重组的文件名取 hashcode 值分散文件夹。   为了安全性，文件最好放在 WEB-INF 文件夹。并且路径是编译后的 out 文件夹。路径采用 this.getServl..
Spring框架详析与开发实战指南
本文档，名为"OpenDocSeries'Spring开发指南V0.6预览版"，详细介绍了Spring框架的技术详解和使用方法，适合已经熟悉Java编程的开发人员参考学习。 Spring框架的核心理念是依赖注入（Dependency Injection, DI）和 ...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值