Spring学习一

最新推荐文章于 2024-08-16 23:28:57 发布
最新推荐文章于 2024-08-16 23:28:57 发布
阅读量41 收藏
点赞数
文章标签： 数据库 java
原文链接：http://www.cnblogs.com/s1127736971/p/7503133.html
版权

明白控制反转，依赖注入，面向切面编程。

控制反转（Inversion of Control）就是依赖注入（Dependency Injection）的另一个表达，意思是本来我们需要一个需要某个对象是 要什么new 什么，而控制反转是反过来先配置好资源。即资源的不同获取方式。  而面向切面编程与面向对象编程的不同在于，面向对象是把一个抽象对象包装，包装对象应该有的方法和属性。而面向切面是，我们包装的是一个事物，一个流程，比如日记记录，什么七七八八的。

 

 

环境搭建

下载好spring 包 这里我用4.0版，下载之后之后导入。

1 Bean的注入方式，Bean中如何注入另一个Bean。

package com.test;

public class Car {//其中一个Bean
   private String factory;
   private double price;
   private int year;
public String getFactory() {
    return factory;
}
public void setFactory(String factory) {
    this.factory = factory;
}
public double getPrice() {
    return price;
}
public void setPrice(double price) {
    this.price = price;
}
public int getYear() {
    return year;
}
public void setYear(int year) {
    this.year = year;
}
public String toString() {
    return "Car [factory=" + factory + ", price=" + price + ", year=" + year
            + "]";
}
public Car(String factory, double price, int year) {
    super();
    this.factory = factory;
    this.price = price;
    this.year = year;
}
public Car (){}//使用参数构造bean必须提供无参数构造模式，不然会报错。
public Car(String factory, double price) {
    super();
    this.factory = factory;
    this.price = price;
}
public Car(String factory, int year) {
    super();
    this.factory = factory;
    this.year = year;
}
   
}



package com.test;

public class Person {//bean中带bean
      private String name;
      private int age;
      private Car car;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Car getCar() {
        return car;
    }
    public void setCar(Car car) {
        this.car = car;
    }
    public Person() {
        
    }
    public String toString() {
        return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
    }
      
}


package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {//测试类
     public static void main(String[] args) {
         ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");//在工程目录下读取bean的配置。
         Car car = (Car)context.getBean("car1");//根据bean配置的ID进行配置
         System.out.println(car);
     //  Car car = context.getBean(Car.class); //这是直接根据类的配置，缺点是当我们有两个同样的Car的时候，会不知道读取哪一出 导致出错。
       Car car2 = (Car)context.getBean("car2");
       System.out.println(car2);
       Car car3 = (Car)context.getBean("car3");
       System.out.println(car3);
       Car car4 = (Car)context.getBean("car4");
       System.out.println(car4);
       
       Person p1 = (Person)context.getBean("person1");
       System.out.println(p1);
       Person p2 = (Person)context.getBean("person2");
       System.out.println(p2);
         
       }
}
<?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-3.0.xsd">

   
   
 <bean id="car1" class="com.test.Car" >
 <property name = "factory" value="futor"/>
 <property name = "price" value="2000"/>
 <property name = "year" value="5"/>
 </bean>
 
 
 <bean id="car2" class="com.test.Car" >
 <constructor-arg value = "aodu"></constructor-arg>
 <constructor-arg value = "50000"></constructor-arg>
 <constructor-arg value = "4"></constructor-arg>
 </bean>
 
 
 
 <!-- 以下两个bean，需要指定参数类型，避免bean不知道你要加载的构造模式是哪个，因为参数类型构造不能重复，以及特殊字符比如<>如何写 -->
 <bean id="car3" class="com.test.Car" >
 <constructor-arg >
 <value><![CDATA[<>auto]]></value>
 </constructor-arg>
 <constructor-arg value = "50000" type="double"></constructor-arg>
 </bean>
 
 <bean id="car4" class="com.test.Car" >
 <constructor-arg value = "aodu" type="java.lang.String"></constructor-arg>
 <constructor-arg value = "5" type="int"></constructor-arg>
 </bean>
   
   
 <!-- 参数里面的Bean应用用ref字符，内部构造的bean外部不能使用 -->
 <bean id ="person1" class="com.test.Person">
 <property name="name" value="xiaozhi"></property>
 <property name="age" value ="21"></property>
 <property name="car" ref="car1"></property>
 </bean>  
 
 <bean id ="person2" class="com.test.Person">
 <property name="name" value="xiaozhi"></property>
 <property name="age" value ="21"></property>
 <property name="car">
 <bean class="com.test.Car">
 <constructor-arg value = "aotuo"></constructor-arg>
 <constructor-arg value = "80000"></constructor-arg>
 <constructor-arg value = "8"></constructor-arg>
 </bean>
 </property>
 </bean>  

</beans>

上面是一个文件名为Bean的xml配置文件

 

级联属性要赋值需要先有初始化。stuct2会自动创建然后赋值上。

集合属性赋值，list，导入util命名空间可以独立实例化。

map属性 用entry key和value-ref

以及properties  用props  配置prop 全都key

以及使用p 来进行赋值

代码区

package com.test;

import java.util.List;

public class NewPerson {
     private String name;
     private int age;
     private List<Car>cars;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public List<Car> getCars() {
        return cars;
    }
    public void setCars(List<Car> cars) {
        this.cars = cars;
    }
     public NewPerson(){}
    @Override
    public String toString() {
        return "NewPerson [name=" + name + ", age=" + age + ", cars=" + cars
                + "]";
    }
     
}


package com.test;

import java.util.Map;

public class OldPerson {
       private String name;
       private int age;
       private Map<String,Car> cars;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Map<String, Car> getCars() {
        return cars;
    }
    public void setCars(Map<String, Car> cars) {
        this.cars = cars;
    }
    public OldPerson(){}
    @Override
    public String toString() {
        return "OldPerson [name=" + name + ", age=" + age + ", cars=" + cars
                + "]";
    }
    
}



package com.test;

import java.util.Properties;

public class DataSource {
     private Properties properties;

    public Properties getProperties() {
        return properties;
    }

    public void setProperties(Properties properties) {
        this.properties = properties;
    }

    @Override
    public String toString() {
        return "DataSource [properties=" + properties + "]";
    }
     
}


测试代码
package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
     public static void main(String[] args) {
         ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");//在工程目录下读取bean的配置。
         NewPerson np = (NewPerson) context.getBean("newperson1");
         System.out.println(np);
         NewPerson np2 = (NewPerson) context.getBean("newperson2");
         System.out.println(np2);
         OldPerson op=(OldPerson) context.getBean("oldperson1");
         System.out.println(op);
         DataSource ds=(DataSource) context.getBean("datasource1");
         System.out.println(ds);
         Person p =(Person) context.getBean("personp");//利用P标签来实例化
         System.out.println(p);
         Person p2 =(Person) context.getBean("personp2");//利用自动装配来实例化
         System.out.println(p2);         
       }
}

xm添加代码

<!-- 用 list表示list数组 -->
 <bean id="newperson1" class="com.test.NewPerson">
 <property name="name" value="小智"></property>
 <property name="age" value="45"></property>
 <property name="cars">
 <list>
 <ref bean="car1"/>
 <ref bean="car2"/>
 <ref bean="car3"/>
 </list>
 </property>
 </bean>

<!-- 可以用util：list来独立实例化，这样需要的bean都能用到 比如下面的newpersons -->
<util:list id="cars1">
<ref bean="car1"/>
<ref bean="car2"/>
<ref bean="car3"/>
</util:list>

<bean id="newperson2" class="com.test.NewPerson">
 <property name="name" value="小盛"></property>
 <property name="age" value="45"></property>
 <property name="cars" ref="cars1"></property>
 </bean>
 
 <!-- map的使用方式 -->
 <bean id="oldperson1" class="com.test.OldPerson">
 <property name="name" value="小红"></property>
 <property name="age" value="45"></property>
 <property name="cars">
 <map>
 <entry key="名字一" value-ref="car1"></entry>
 <entry key="名字二" value-ref="car2"></entry>
 <entry key="名字三" value-ref="car3"></entry>
 </map>
 </property>
 </bean>

<!-- 常见的集合类，可以用来存储用户密码等等 -->
<bean id="datasource1" class="com.test.DataSource">
<property name="properties">
<props>
<prop key="UserName">无名</prop>
<prop key="PassWord">1123456789</prop>
<prop key="DatabaseDriver">www.sql.driver.link</prop>
</props>
</property>
</bean>

<!-- 这是利用 p 标签来在bean中设置属性，记得开头填写标签 -->
<bean id="personp" class="com.test.Person" p:age="10" p:name="cool" p:car-ref="car1"></bean>

<!-- 自动装配byName 则在setter方法名字一样装配，byType则根据类型，但是必须唯一 -->
<!-- 缺点多 整合框架会用到 -->
<bean id="personp2" class="com.test.Person" p:age="10" p:name="cool" autowire="byName"></bean>

 

 

 

 

 

 

 Bean之间的关系

继承关系parent

继承的父类里面的信息可以被子类重写，autowire 不能继承，可以专门写一个abstract的类来当抽象类，但是abstract类不能被实例化

依赖关系depends-on

依赖于某物的意思，必须有某物才能这个实例，但是内容不一定要用某物

package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
     public static void main(String[] args) {
         ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");//在工程目录下读取bean的配置。
       
         
         Person p3 =(Person) context.getBean("pperson");//继承关系
         System.out.println(p3);
         
         Person p4 =(Person) context.getBean("persond");//依赖关系
         System.out.println(p4);
         
         
       }
}

bean文件添加

<!-- 继承关系，重写，autowire不能重写。但是abstract 设置为true就不能实例化 -->
<bean id="persons" class="com.test.Person" p:name="xiaoxiaozhi" p:age="88" abstract="true"></bean>
<bean id="pperson" parent="persons" name="小智"></bean>

<!-- 依赖关系 depends-on ，依赖于cardpend的意思，必须有cardpend才能这个实例，但是内容不一定要用cardpend -->
<bean id = "cardepend" class="com.test.Car" p:factory="hongjing" p:price="888" p:year="5"></bean>
<bean id="persond" parent="persons" depends-on="cardepend" p:car-ref="cardepend"></bean>

 

 

 

Bean的作用域

bean是默认单例模式 即Singleton 但是可以修改成原型模式，原型模式是prototype，单例模式是在获取容器IoC构造的时候就构造好，而原型模式是我们之后需要的时候才构造，以下代码测试

package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
     public static void main(String[] args) {
         ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");//在工程目录下读取bean的配置。
       
     
         Car car1= (Car) context.getBean("carsingle");
         Car car2= (Car) context.getBean("carsingle");
         Car car3= (Car) context.getBean("carproto");
         Car car4= (Car) context.getBean("carproto");
         System.out.println(car1==car2); 
         System.out.println(car3==car4); 
         //这段代码将会输出 true  false ，原因是在默认的单例模式下，car1和car2都是单例的引用，而在原型模式下
         //car3和car4是相当于需要的时候才创建，如果给car构造函数一个简单输出，会发现，在 ApplicationContext
         //装配好的时候就已经构造好单例模式，而原型模式是在创建好的时候才构造好。
       
       }
}

添加的bean

<!--默认是singleton，可以改成原型。-->
<bean id="carsingle" class="com.test.Car" p:factory="audi" p:price="5000" p:year="5" scope="singleton"></bean>
<bean id="carproto" class="com.test.Car" p:factory="audi" p:price="5000" p:year="5" scope="prototype"></bean>

 

 

 

PropertyPlaceholderConfigurer 是 BeanFactory 后置处理器的实现，也是 BeanFactoryPostProcessor 接口的一个实现。允许将上下文（配置文件）中的属性值放在另一个单独的标准 JavaProperties 文件中去。在 XML 文件中用类似 EL 表达式的 ${key} 替换指定的 properties 文件中的值。这样的话，以后更改参数时，我们直接替换 properties 文件中的值就可以了。

一些关键参数的设置就可以放在xxx.properties 里面，因为bean很多，可以很便捷。

package com.test;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
     public static void main(String[] args) {
         ApplicationContext context = new       ClassPathXmlApplicationContext("Beans.xml");//在工程目录下读取bean的配置。
     Database db = (Database) context.getBean("database");
         System.out.println(db.getName());
         //成功输出root
       }
}


package com.test;

public class Database {//假设这是我们要配置的database
    private String name;
    private String password;
    private String url;
    private String driver;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public String getUrl() {
        return url;
    }
    public void setUrl(String url) {
        this.url = url;
    }
    public String getDriver() {
        return driver;
    }
    public void setDriver(String driver) {
        this.driver = driver;
    }
    
}

bean添加

<!--使用Beanfactory的后置处理器，就需要添加对应的标签 context 后面的value属性用"${xx}"  配置文件的名字-->
<context:property-placeholder location="classpath:db.properties"/>
<bean id="database" class="com.test.Database">
<property name="name" value="${name}"></property>
<property name="password" value="${password}"></property>
<property name="url" value="${url}"></property>
<property name="driver" value="${driver}"></property>

对应的 db.properties文件是

name=root
password=123456
url=jdbc
driver=jdbc.driver

 

转载于:https://www.cnblogs.com/s1127736971/p/7503133.html

weixin_30536513
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
webjs 数据库 离线读取本地数据库源码-SAAS 本地化及未来之窗行业应用跨平台架构
cybersnow精通 28 门计算机语言，凭借其超凡的技术能力，成功开发过上万个应用，广泛涉及政府、商业、个人等众多领域，甚至在检察院、环保局、公安局等专业场景中也大放异彩。不仅熟练掌握单片机和物联网开发，在软件架构设计方面更是独树一帜，自创了跨平台软件
08-15 178
【代码】webjs 数据库 离线读取本地数据库源码-SAAS 本地化及未来之窗行业应用跨平台架构。
[Qt][Qt窗口][下]详细讲解
SnowK博客
08-13 3756
[Qt][Qt窗口][下]详细讲解
mysql介绍
weixin_57763462的博客
08-14 302
丰富的存储引擎：MySQL 提供了多种存储引擎，如 InnoDB、MyISAM、Memory 等，每种存储引擎都有其特定的应用场景和优势。多语言支持：MySQL 支持多种编程语言，包括 C、C++、Python、Java、Perl、PHP 等，并提供了相应的 API。安全性：MySQL 提供了灵活的权限和密码系统，支持基于主机的验证，并且所有的密码传输都采用加密形式，确保了数据的安全性。管理工具：MySQL 提供了丰富的管理工具，如命令行客户端、图形界面管理工具等，方便用户进行数据库的管理和维护。
旅游网站
weixin_43213064的博客
08-16 612
【代码】springboot旅游网站
【Redis】Redis 初探：特性、应用场景与高并发架构演进之路
Hsusan的博客
08-13 895
在进⾏技术学习过程中，由于⼤部分读者没有经历过⼀些中⼤型系统的实际经验，导致⽆法从全局理解⼀些概念，所以本⽂以⼀个 “电⼦商务” 应⽤为例，介绍从⼀百个到千万级并发情况下服务端的架构的演进过程，同时列举出每个演进阶段会遇到的相关技术，让⼤家对架构的演进有⼀个整体的认知，⽅便⼤家对后续知识做深⼊学习时有⼀定的整体视野。
[PHP]-Laravel中Group By引发的问题思考
hmx224_2014的专栏
08-16 260
Laravel 和 ThinkPHP 是两个不同的 PHP 框架，它们在底层使用了相同的 SQL 查询语言来与数据库交互。然而，由于框架的设计和实现方式不同，它们在生成 SQL 查询时可能会表现出一些细微的差异，包括对GROUP BY 子句的处理。在调用查询公司在线报告接口时，发现我请求的数据室20条每页，但是经查询存在16,17条的都有，并且后几页也不稳定，就一直查询问题。
健身房管理系统
寒夜
08-13 840
【代码】springboot健身房管理系统
SQL Server 时间算差值/常用函数
学习和分享
08-13 270
DATEDIFF()是计算时间差值的直接工具，而DATEADD()CONVERT()CAST()DATEPART()和EOMONTH()等函数则提供了额外的灵活性和控制能力，以满足更复杂的时间处理需求。
MySQL系统变量innodb_autoinc_lock_mode
zxrhhm的博客
08-14 732
`innodb_autoinc_lock_mode` 是 MySQL InnoDB 存储引擎的一个系统变量，它控制着自增（AUTO_INCREMENT）值的锁定机制。
Mybatis XML 数据源为 Oracle 之批量插入或更新 Merge Into 的具体介绍与使用
欢迎来到 ABin-阿斌的博客：写一生代码，创一世佳话，筑一览芳华。
08-12 712
由于近期在所开发的项目中，对于数据入库，有存在即更新，不存在则插入的需求，因此发现了 Oracle中的 MergeInto 命令。本文将对MergeInto的用法进行介绍并将 MergeInto 和批量插入进行结合，同时还会对在 MergeInto 开发中遇到的问题进行总结。MergeInto 命令是 Oracle9i 中新增的命令，有了 MergeInto 语句，我们对数据能够不仅仅只做单一的插入或单一的更新，而是可以将更新与插入一起操作。
基于JAVA生产制造执行系统设计与实现(源码+论文+讲解等)
程序员阿龙的博客
08-13 1067
当下，如果 还依然使用纸质文档来记录并且管理相关信息，可能会出现很多问题，比如原始文件的丢失，因为采用纸质文档，很容易受潮或者怕火，不容易备份，需要花费大量的人员和资金来管理用纸质文档存储的信息，最重要的是数据出现问题寻找起来很麻烦，并且修改也困难，如果还这样操作会造成很大的资源浪费和经济损失。所以，对于本课题研究的产品生产制造信息的管理就需要有一款软件来代替手工操作，因此MES生产制造执行系统就应运而生。MES生产制造执行系统运用的工具包括Eclipse，Tomcat以及Navicat等。
企业架构MySQL读写分离
A1357924680_的博客
08-16 478
DAU ： 2000 （每日活跃⽤户数） 之前业务中是单台 MySQL 提供服务，使用多台MySQL数据库务器，降低单台压力，实现集群架构的稳定性和高可用性 数据的一致性 完整性 replication通过业务比对和分析发现，随着活跃用户数增多，读取数据的请求变多，故着重解决读取数据的压力。基于主从复制的基础上，常见的数据库负载均衡使用的是读写分离方式。在业务代码中，数据库的操作，不直接连接数据库，而是先请求到中间件服务器（代理）由代理服务器，判断是读操作去从数据服务器，写操作去主数据服务器。
17.session不共享问题
最新发布
卷土的博客
08-16 108
多台Tomcat并不共享session存储空间，当请求切换到不同的tomcat服务时导致数据丢失问题。考虑到以后微服务部署多个项目，也就是多个tomcat就会出现session不共享问题。
《零散知识点 · Vue-admin 模板项目》
山人行
08-12 831
permission.js 里面的：const whiteList = [‘/login’] // 不重定向白名单配在route里面的顶部即可。this获取方式：提示：{{this.$route.params.alert}}提示：{{this.$route.query.alert}}
基于vue框架的爱看电影网站v4o92（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
08-15 821
项目功能：用户,电影分类,电影信息,电影评分基于Vue框架的爱看电影网站项目功能丰富多样，旨在为用户提供一个集电影浏览、信息查询、观影体验、互动交流于一体的综合性平台。
Pydantic serialisation 结合 tortoise-orm 使用文档
????Fender的博客????
08-16 706
Pydantic serialisation 结合 tortoise-orm 使用文档
安卓中Room持久化库的使用
故事不长丨的博客
08-13 492
在Android开发中，Room是Google提供的一个持久化库，旨在为应用提供SQLite的抽象层，以简化数据库的访问和操作。相比直接使用SQLite，Room提供更清晰、更简洁的数据库访问机制。
2024年8月16日（运维自动化 ansible）
weixin_70751333的博客
08-16 691
group01][group02]},},},[root@m0 ~]# ansible group02 -m ping #192.168.8.183没有免密，报错[root@m0 ~]# vim /etc/ansible/hosts #重新修改文件[group01][group02]other[root@m0 ~]# ansible group02 -m ping #不报错了[root@m0 ~]# ansible other -m ping #单独也是成功的},
HVV护网面经速记速记
weixin_65633498的博客
08-13 394
2.利用T3协议配合RMP或ND接口反向发送反序列化数据(CVE2017-3248、CVE2018-2628、CVE2018-2893、CVE2018-3245、CVE-2018-3191、CVE-2020-14644、CVE-2020-14645)还有利用IIOP协议的CVE-2020-2551。1.直接通过T3协议发送恶意反序列化对象(CVE-2015-4582、CVE-2016-0638、CVE-2016-3510、CVE-2020-2555、CVE-2020-2883)而5.0以下的版本不存。
Spring MVC 框架详解与学习指南
"这是一份关于Spring MVC的学习笔记，源自传智播客的课程，由讲师传智.燕青讲解。笔记主要介绍了Spring MVC的基本概念、工作流程以及关键组件的作用，帮助学习者深入理解这一流行的Java Web开发框架。" Spring MVC...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值