周报总结---集合、Spring--IOC和DI

已于 2022-12-30 16:20:30 修改
阅读量1.7k 收藏
点赞数
分类专栏： 总结 spring java基础 文章标签： spring java servlet
于 2022-12-30 13:24:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a_s_x_y/article/details/128491605
版权
spring 同时被 3 个专栏收录
5 篇文章 0 订阅
订阅专栏
java基础
5 篇文章 0 订阅
订阅专栏
总结
1 篇文章 0 订阅
订阅专栏

集合、Spring--IOC和DI

集合

概念

  • 对象的容器，定义了对多个对象进行操作的常用方法。可实现数组的功能。
  • 位置：java.util.*
  • 和数组区别
    • 数组长度固定，集合长度不固定。
    • 数组可以存储基本类型和引用类型，集合只能存储引用类型。

Collection体系集合

在这里插入图片描述

Collection父接口

  • 特点：代表一组任意类型的对象，无序、无下标。
  • 常用方法：
方法描述
boolean add(Object obj)添加一个对象数据
boolean addAll(Collection c)将一个集合中的所有对象添加到此集合中
void clear()清空此集合中的所有对象
boolean contains(Object o)检查此集合中是否包含o对象
boolean equals(Object o)比较此集合是否与指定对象相等
boolean isEmpty()判断此集合是否为空
boolean remove(Object o)在此集合中移除o对象
int size()返回此集合中的元素个数
Object[] toArray()将此集合转换成数组

注：遍历同时不能使用集合删除方法，否则出现并发修改异常，可使用迭代器的删除方法。
遍历方法：
1、增强for循环
2、迭代器

public class TestCollection2 {
	public static void main(String[] args) {
		//新建Collection对象
		Collection collection=new ArrayList();
		Student s1=new Student("张三", 20);
		Student s2=new Student("张无忌", 18);
		Student s3=new Student("王二", 22);
		//1添加数据
		collection.add(s1);
		collection.add(s2);
		collection.add(s3);
		System.out.println("元素个数:"+collection.size());
		System.out.println(collection.toString());
		//2删除
		//collection.remove(s1);
		//collection.remove(new Student("王二", 22));
//		collection.clear();
//		System.out.println("删除之后:"+collection.size());
		//3遍历
		//3.1 增强for
		System.out.println("-------增强for----");
		for (Object object : collection) {
			Student s=(Student)object;
			System.out.println(s.toString());
		}
		//3.2迭代器: hasNext()  next();  remove(); 迭代过程中不能使用使用collection的删除方法
		System.out.println("-------迭代器----");
		Iterator it=collection.iterator();
		while(it.hasNext()) {
			Student s=(Student)it.next();
			System.out.println(s.toString());
		}
		//4判断
		System.out.println(collection.contains(s1));
		System.out.println(collection.isEmpty());
		
	}
}

List接口及其实现类

List接口
  • 特点：有序、有下标、元素可以重复。
  • 常用方法：
方法描述
void add(int index, Object o)在index位置插入对象o。
boolean addAll(int index, Collection c)将一个集合中的元素添加到此集合中的index位置。
Object get(int index)返回集合中指定位置的元素。
List subList(int fromIndex, int toIndex)返回fromIndex和toIndex之间的集合元素。
  • 遍历方法：
    1、普通for循环
    2、增强for循环
    3、迭代器

案例

public class TestList {
	public static void main(String[] args) {
		//先创建集合对象
		List list=new ArrayList();
		//1添加元素
		list.add("苹果");
		list.add("小米");
		list.add(0, "华为");
		System.out.println("元素个数:"+list.size());
		System.out.println(list.toString());
		//2删除元素
		//list.remove("苹果");
//		list.remove(0);
//		System.out.println("删除之后:"+list.size());
//		System.out.println(list.toString());
		//3遍历
		//3.1使用for遍历
		System.out.println("-----3.1使用for遍历-----");
		for(int i=0;i<list.size();i++) {
			System.out.println(list.get(i));
		}
		//3.2使用增强for
		System.out.println("-----3.2使用增强for-----");
		for (Object object : list) {
			System.out.println(object);
		}
		//3.3使用迭代器
		Iterator it=list.iterator();
		System.out.println("-----3.3使用迭代器-----");
		while(it.hasNext()) {
			System.out.println(it.next());
		}
		//3.4使用列表迭代器 ,和Iterator的区别，ListIterator可以向前或向后遍历，添加、删除、修改元素
		ListIterator lit=list.listIterator();
		System.out.println("------使用列表迭代器从前往后-------");
		while(lit.hasNext()) {
			System.out.println(lit.nextIndex()+":"+lit.next());
		}
		System.out.println("------使用列表迭代器后往前-------");
		while(lit.hasPrevious()) {
			System.out.println(lit.previousIndex()+":"+lit.previous());
		}
		
		//4判断
		System.out.println(list.contains("苹果"));
		System.out.println(list.isEmpty());
		
		//5获取位置
		System.out.println(list.indexOf("华为"));
	}
}
List实现类
ArrayList

  • 数组结构实现，查询快、增删慢。

  • JDK1.2版本、线程不安全。

  • 遍历方式
    1、普通for循环
    2、增强for循环
    3、迭代器

LinkedList

  • 链表结构实现，增删快，查询慢。

  • JDK1.2版本、线程不安全。

  • 遍历方式
    1、普通for循环
    2、增强for循环
    3、迭代器

Vector（了解）

数组结构实现，查询快、增删慢。
JDK1.0版本，线程安全、运行效率比ArrayList较慢。

List集合体系总结

  • List：一个有序容器，所以可以允许重复的对象，可以插入多个null

  • ArrayList：底层是动态数组，默认是空数组，若存值则扩容至10，如果不够则按照1.5倍进行扩容

  • LinkedList：底层是采用双向链表

  • Vector：线程安全。底层是可扩展的对象数组，可以使用整数索引访问，并且Vector的大小可以根据需要增长或缩小

ArrayList、LinkedList、Vector的区别

  • ArrayList和Vector是基于数组实现，ArrayList线程不安全，速度快，Vector线程安全，速度慢。因为底层是数组所以查询、修改快，增删慢。
  • LinkedList底层是双向链表，线程不安全，增删快，查询修改慢
  • ArrayList和Vector是使用Object类型的数组存储，ArrayList扩容是1.5倍和Vector扩容是2倍，扩容实际上是将数组拷贝复制到另一个数组中

Set接口及其实现类

Set接口
  • 特点：无序、无下标、元素不可重复。
  • 方法：全部继承自Collection中的方法。
  • 遍历方法
    1、增强for循环
    2、迭代器
实现类
HashSet
  • 基于HashCode实现元素不重复。
  • 当存入元素的哈希码相同时，会用equals进行确认，结果为true，拒绝后者存入。
  • 遍历方法
    1、增强for循环
    2、迭代器
LinkedHashSet
  • 链表实现的HashSet，按照链表进行存储，即可保留元素的插入顺序。
TreeSet
  • 基于排列顺序实现元素不重复。
  • 实现了SortedSet接口，对集合元素自动排序。
  • 元素对象的类型必须实现Comparable接口，指定排序规则（自然排序）。
  • 通过CompareTo方法确定是否为重复元素。
  • 遍历方法
    1、增强for
    2、迭代器
    注：元素必须要实现Comparable接口,compareTo()方法返回值为0,认为是重复元素。

Comparable接口CompareTo方法

public class Person implements Comparable<Person>{
	private String name;
	private int age;
	public Person() {
		// TODO Auto-generated constructor stub
	}
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	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;
	}
	@Override
	public String toString() {
		return "Person [name=" + name + ", age=" + age + "]";
	}
	//先按姓名比，然后再按年龄比
	@Override
	public int compareTo(Person o) {
		int n1=this.getName().compareTo(o.getName());
		int n2=this.age-o.getAge();
		return n1==0?n2:n1;
	}
}

Comparator接口

public class TestComparator {
	public static void main(String[] args) {
		//创建集合,并指定比较规则
		TreeSet<Person> persons=new TreeSet<>(new Comparator<Person>() {
			@Override
			public int compare(Person o1, Person o2) {
				int n1=o1.getAge()-o2.getAge();
				int n2=o1.getName().compareTo(o2.getName());
				return n1==0?n2:n1;
			}
		});
		
		Person p1=new Person("xyz", 20);
		Person p2=new Person("hello", 22);
		Person p3=new Person("zhangsan", 25);
		Person p4=new Person("lisi", 25);
		
		persons.add(p1);
		persons.add(p2);
		persons.add(p3);
		persons.add(p4);
		System.out.println(persons.toString());
	}
}
set体系总结

  • 不允许重复对象。无序容器，无法保证每个元素的存储顺序，TreeSet通过 Comparator 或者 Comparable 维护了一个排序顺序。因为是无序的所以只允许一个 null 元素。

  • TreeSet保证对象的有序性

    • 数据会按自然排序（可以理解为从小到大排序）
    • 不可存储null
    • 数据不可重复
    • 非线程安全
    • TreeSet底层依赖于TreeMap，TreeMap的数据结构是二叉树（红黑树），由底层数据结构决定了
    • TreeSet中元素有序且唯一。
    • 使用TreeSet时，如果添加对象的话，就必须去实现Comparable接口，当然也可以实现Comparator接口来保证对象的有序性。

  • HashSet 的实现原理

    • HashSet底层使用了哈希表来支持的，特点：存储快, 底层由HashMap实现
    • 往HashSet添加元素的时候，HashSet会先调用元素的hashCode方法得到元素的哈希值 ，然后通过元素的哈希值经过移位等运算，就可以算出该元素在哈希表中的存储位置。
    • 如果算出的元素存储的位置目前没有任何元素存储，那么该元素可以直接存储在该位置上
    • 如果算出的元素的存储位置目前已经存在有其他的元素了，那么还会调用该元素的equals方法与该位置的元素再比较一次，如果equals方法返回的是true，那么该位置上的元素视为重复元素，不允许添加，
      如果返回的是false，则允许添加 。

  • Hash碰撞以及常见的解决方案

Hash碰撞 : 对象Hash的前提是实现equals()和hashCode()两个方法，那么HashCode()的作用就是保证对象返回唯一hash值，但当两个不同对象计算值一样时，这就发生了碰撞冲突。

解决方案：

  • 开放地址法(再散列法)开放地执法有一个公式:Hi=(H(key)+di) MOD m i=1,2,…,k(k<=m-1)其中，m为哈希表的表长。di 是产生冲突的时候的增量序列。如果di值可能为1,2,3,…m-1，称线性探测再散列。
    如果di取1，则每次冲突之后，向后移动1个位置.如果di取值可能为1,-1,2,-2,4,-4,9,-9,16,-16,…kk,-kk(k<=m/2)，称二次探测再散列。如果di取值可能为伪随机数列。称伪随机探测再散列。
  • 再哈希法Rehash当发生冲突时，使用第二个、第三个、哈希函数计算地址，直到无冲突时。
    缺点：计算时间增加。
    比如上面第一次按照姓首字母进行哈希，如果产生冲突可以按照姓字母首字母第二位进行哈希，再冲突，第三位，直到不冲突为止.这种方法不易产生聚集，但增加了计算时间。
  • 链地址法（拉链法）将所有关键字为同义词的记录存储在同一线性链表中.基本思想:将所有哈希地址为i的元素构成一个称为同义词
    链的单链表，并将单链表的头指针存在哈希表的第i个单元中，因而查找、插入和删除主要在同义词链中进行。链地址法适用于经常进行插入和删除的情况。

Map体系集合

在这里插入图片描述

Map接口及其实现类

Map接口
  • 特点
    • 用于存储任意键值对(Key-Value)。
    • 键：无下标、不可以重复（唯一）。
    • 值：无下标、可以重复 。
  • 常用方法
方法名描述
V put(K key,V value)将对象存入到集合中，关联键值。key重复则覆盖原值。
Object get(Object key)根据键获取对应的值。
Set keySet()返回所有key。
Collection values()返回包含所有值的Collection集合。
Set<Map.Entry<K,V>> entrySet()键值匹配的Set集合。
  • 遍历方法
    1、entrySet()方法
    2、keySet()

例子

public class TestMap {
	public static void main(String[] args) {
		//创建Map集合
		Map<String, String> map=new HashMap<>();
		//1添加元素
		map.put("cn", "中国");
		map.put("uk", "英国");
		map.put("usa", "美国");
		map.put("cn", "zhongguo");
		
		System.out.println("元素个数:"+map.size());
		System.out.println(map.toString());
		
		//2删除
//		map.remove("usa");
//		System.out.println("删除之后:"+map.size());
		//3遍历
		//3.1使用keySet();
		System.out.println("------keySet()--------");
		//Set<String> keyset=map.keySet();
		for (String key : map.keySet()) {
			System.out.println(key+"-----"+map.get(key));
		}
		//3.2使用entrySet()方法
		System.out.println("------entrySet()-----");
		//Set<Map.Entry<String, String>> entries=map.entrySet();
		for (Map.Entry<String, String> entry : map.entrySet()) {
			System.out.println(entry.getKey()+"---------"+entry.getValue());
		}
		//4判断
		System.out.println(map.containsKey("cn"));
		System.out.println(map.containsValue("泰国"));
		
	}
}
实现类
HashMap
  • JDK1.2版本，线程不安全，运行效率快。
  • 允许用null 作为key或是value。
  • 存储结构：哈希表。
  • 遍历方法
    1、使用keySet()
    2、使用entrySet()
TreeMap
  • 实现了SortedMap接口(Map的子接口)，可以对key自动排序，Key需实现Comparable接口。
  • 遍历方法
    1、使用keyset
Hashtable ：
  • JDK1.0版本，线程安全，运行效率慢；不允许null作为key或是value。
Properties ：
  • Hashtable的子类，要求key和value都是String。通常用于配置文件的读取。
Map体系总结
  • Map: 与Collection并列，用来存储具有映射关系(key-value)的数据
    • HashMap:哈希表结构存储数据，key值可以为null
    • TreeMap:红黑树算法的实现
    • HashTable:哈希表实现，key值不可以为null
    • Properties:HashTable的子类，键值对存储数据均为String类型，主要用来操作以.properties
      结尾的配置文件。
  • 存储数据是以key，value对进行存储，其中key值是以Set集合形式存储，唯一且不可重复。
    value是以Collection形式存储，可以重复。
  • 优缺点
    • Map不是collection的子接口或者实现类。Map是一个接口。
    • Map 的 每个 Entry 都持有两个对象，也就是一个键一个值，Map 可能会持有相同的值对象但键对象必须是唯一的。
    • TreeMap 也通过 Comparator 或者 Comparable 维护了一个排序顺序。
    • Map 里你可以拥有随意个 null 值但最多只能有一个 null 键。
    • Map 接口最流行的几个实现类是 HashMap、LinkedHashMap、Hashtable 和 TreeMap。（HashMap、TreeMap最常用）
  • HashTable、HashMap、TreeMap的区别
    • Hashtable、HashMap、TreeMap都实现了Map接口，使用键值对的形式存储数据和操作数据。
    • Hashtable是java早期提供的，方法是同步的（加了synchronized）。key和value都不能是null值。
    • HashMap的方法不是同步的，支持key和value为null的情况。行为上基本和Hashtable一致。由于Hashtable是同步的，性能开销比较大，一般不推荐使用Hashtable。通常会选择使用HashMap。
    • HashMap进行put和get操作，基本上可以达到常数时间的性能
    • TreeMap是基于红黑树的一种提供顺序访问的Map，和HashMap不同，它的get或put操作的时间复杂度是O(log(n))。具体的顺序由指定的Comparator来决定，或者根据键key的具体顺序来决定。
  • HashMap的底层数据存储结构

JDK1.7采用 : 数组 + 链表结构
JDK1.8采用 : 数组 + 链表 + 红黑树
红黑树：jdk1.8最重要的就是引入了红黑树的设计，当hash表的单一链表长度超过 8 个的时候，链表结构就会转为红黑树结构。

  • HashMap的底层数据存储结构为哈希表加红黑树。实现过程如下
    • 调用HashMap的无参构造方法，加载因子loadFactor赋值0.75，table数组是空。
    • 当添加第一个元素时，创建长度16的数组，threshold=12。
    • 当‘链表长度大于等于8时，并且数组长度大于等于64时，链表调整红黑树
    • 当红黑树的节点个数小于6时，调整为链表
    • 当HashMap的容量超出阈值时，扩容为原来大小的2倍，减少元素的移动，提高效率。
  • HashMap链表和红黑树转化时机
    当链表长度超过8且哈希表容量大于64，会将链表转化为红黑树。而当红黑树的大小小于6，
    则由树转化为链表。

Spring—IOC和DI

Spring主要是三种方式
1、xml配置文件
2、注解开发
3、xml+注解开发
概念：Spring是分层的轻量级开源框架。以IOC（控制反转）和 AOP（面向切面编程）为内核。

IOC

是一种设计思想。它的目的是指导我们设计出更加松耦合的程序。
一句话来说就是：bean的创建和销毁交给spring容器管理。

xml配置文件方式

步骤分析及代码实现
  1. 导入依赖(spring-context)
<!--导入spring的ioc核心依赖-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.1.5.RELEASE</version>
</dependency>
  1. 编写UserDao接口及其实现类
  2. 编写一个spring的配置文件(名字任意)
    • 通过bean标签配置dao
<?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="userDao" class="cn.dao.impl.UserDaoImpl"/>
</beans>
  1. 编写测试代码
    • 获取spring容器(工厂)对象
    • 通过工厂对象获取dao的对象
    • 调用save方法
public class TestHelloIOC {
    @Test
    public void testIocHello(){
        //- 获取spring容器(工厂)对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");

        //- 通过工厂对象获取dao的对象
        UserDao userDao = (UserDao) context.getBean("userDao");

        //- 调用save方法
        userDao.save();
    }
}

Spring的API体系

主要关注两个BeanFactory和ApplicationContext
在这里插入图片描述

BeanFactory和ApplicationContext的关系
  • BeanFactory是ApplicationContext的父接口
  • BeanFactory初始化配置文件中单实例对象的时机:每次调用getBean的时候才创建对应的对象
  • ApplicationContext初始化配置文件中单实例对象的时机:在工厂对象初始化完成的时候已经创建好了
实现类
* FileSystemXmlApplicationContext【了解】
	功能：从指定磁盘目录加载xml配置文件，创建spring的ioc容器

* ClassPathXmlApplicationContext
	功能：从类路径下加载xml配置文件，创建spring的ioc容器
	
* AnnotationConfigApplicationContext
	功能：加载注解配置类，创建spring的ioc容器

Spring配置文件

配置文件的名字可以放在任意位置,名字任意

Bean标签
<!--
        bean:将配置的对象加入spring容器管理
            id属性(name属性):给bean起个名字,要保证当前项目中唯一
            class属性:配置对象对应的全限定类名(类且有无参构造器)

            其他的配置:
            scope属性:配置对象的作用范围(单实例还是多实例等)
                常见俩值:
                    singleton:默认值,单实例对象
                    prototype:多实例对象,一般用不上,struts2框架中action是多实例
            init-method属性:指定对象创建成功之后要执行的方法(初始化操作),我们一般用不上,框架底层使用
            destroy-method属性:指定对象销毁之前要执行的方法(销毁操作),我们一般用不上,框架底层使用

    -->
<bean id="userDao" class="cn.dao.impl.UserDaoImpl" scope="singleton" init-method="init" destroy-method="dest"/>

DI依赖注入

set方法注入

<!--依赖注入:set-->
<bean id="userService" class="cn.service.impl.UserServiceImpl">
    <!--property:使用set方式给属性进行赋值操作
                name属性:需要赋值的属性名称
                ref属性:属性类型为引用类型且在spring容器中存在,值就是在spring容器中bean对象的名字
                value属性:属性类型为简单类型(包含基本类型、包装类及string类型)
        -->
    <property name="userDao" ref="userDao"/>
</bean>

构造方法注入

<!--依赖注入:构造器方法-->
<bean id="userService1" class="cn.service.impl.UserServiceImpl">
     <!--
            constructor-arg:使用构造器进行赋值操作
                name属相:构造方法中形参的名字
                value属性:给简单类型进行赋值
                ref属性:给引用类型进行赋值操作,值就是spring容器中对象的id值
        -->
    <constructor-arg name="age" value="12"/>
    <constructor-arg name="name" value="tom"/>
    <constructor-arg name="userDao" ref="userDao"/>
</bean>

p命名空间注入(了解)

本质上也是set方法，在此基础上进行了简化

步骤:

  1. 需要在spring的配置文件中引入p名称空间
  2. 在需要注入的bean标签中通过 p:属性=“” 或者 p:属性-ref=""方式注入
    在这里插入图片描述
<!--p名称空间注入-->
<bean id="dataSource2" class="com.alibaba.druid.pool.DruidDataSource"
      p:driverClassName="com.mysql.jdbc.Driver" p:url="jdbc:mysql:///travel"
      p:username="root" p:password="1234"/>

依赖注入的数据类型

  • 普通数据类型
    通过标签的value属性注入数据

  • 引用数据类型
    通过标签的ref属性注入数据

  • 集合数据类型

注解开发

Spring—IOC和DI注解开发

个人对Spring理解看法

Spring是一个轻量级框架，使用Spring极大的方便了我们对程序的开发，原因：

  • 不用我们自己手动频繁创建对象和管理对象
    • 因为spring替我们创建和管理了对象，方便我们更好的关心逻辑代码方面的开发
  • spring增加了横向的开发（AOP）
    • 对于oop来说我们更多地是一种纵向的开发，相当于是一层叠一层的开发
    • 但是对于很多时候，比如说要运行日志记录这些，需要横向抽取代码的时候，oop就无法满足，这个时候需要AOP来帮助实现
  • spring的核心就是IOC和AOP
  • 配置文件和注解是可以相互替换，相等价的

spring对于我个人来说极大地方便了开发，减少了代码的耦合，但是他也带来了一个很麻烦的事情就是配饰文件太多，太麻烦了。对于spring的开发最好的方法就是使用配置文件+注解的方式开发

两周学习出现的问题

导入jdk8的源码包到idea中失败

下两周计划

1、解决导入jdk8的源码包到idea中失败
2、复习spring框架AOP、mybatis
3、spring注解学习
若上面完成可完成下面的
3、mybatis源码阅读
4、springmvc框架

~^~^
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
一个基于java springboot vue mysql的开源每周工作汇报系统 前后端分离 支持在线写周报、图片上传、支持共享阅览pdf、markdown格式的文件
usualheart的博客
08-21 995
zhoubao 项目地址： https://github.com/usualheart 一个用于研究生/博士/工作的每周工作汇报系统，springboot+vue+mysql。支持在线写周报、上传图片，支持pdf、markdown格式的周报文件。支持共享查看。 效果展示 登录界面 首页北京与bing.com图片同步,每天都有新鲜感。 Markdown编辑器 支持在线使用Markdown语法写周报。 表格式周报与图片上传 支持以在线表格的形式填写每周工作情况，同时还支持上传图片进行说明。 部署方法 创建
springboot+mybatis开发日、周、月、年报
Grey_fantasy的博客
04-11 2005
springboot+mybatis日、周、月、年报
基于SSM实现简单的周报系统
qq_42137703的博客
08-10 1036
SSM实现简单的周报系统 声明：本人是小白初学者，本系统仅是用来练练手（且是与他人合作实现），加强对SSM框架知识的运用，整个过程中还是很迷的，有不足之处还请指点！ 开发环境：IDEA       JDK: 1.8      maven      tomcat 8.5 如何创建maven项目这里先不说明 源码： 以下内容只
Ruby 周报2004/11/1--11/7
Ruby语言
11-10 1518
[RSS::Maker 0.1.0] RSS::Maker发布，作者Kouhei Sutou ，生成RSS的模块。[NARF 0.6.1] 作者：Patrick May。NARF是一个对cgi.rb增强的模块，关注于易测试性和快速开发。[Needle 1.0] Jamis Buck 发布了Needle 1.0 ，这是一个Ruby的IO
周报7＞＞＞
bss13287350062的博客
09-19 101
Maven 管理jar包：下载、保存、编译、更新 仓库： 1.远程仓库/中央仓库：本质上就是一个国外的网址，提供了所有的jar包 2.镜像仓库：就是一个国内的网址，已经下载好了jar包 3.本地仓库：就是一个你自己创建的文件夹，存放下载好的jar包 坐标：存放jar包的路径 依赖：Ajar包可能会依赖着好多jar包，maven都会管理所有的jar包 使用步骤：解压maven压缩包，找到setting.xml文件，需要改两处（本地仓库+镜像仓库） 常用的maven命令： 1.clean：清
SSM基于+Vue的学生实践管理平台开发vcjxj 试题
CK3029的博客
08-12 1114
本项目旨在开发一个基于SSM（Spring+SpringMVC+MyBatis）框架与Vue.js技术栈的学生实践管理平台（vcjxj），旨在通过先进的技术手段，实现学生实践活动的全流程信息化管理，提高管理效率，增强用户体验。系统内容：班级,学生,教师,企业,竞赛学科,竞赛信息,竞赛报名,竞赛成绩,课题信息,选题信息,开题报告,论文提交,论文成绩,岗位分类,行业领域,招聘信息,应聘申请,学生录用,实习信息,周报上交,深造申请,竞赛获奖,大创项目,项目申请,项目类型。
滴滴开源了哪些有意思的项目？
公众号：Java后端
07-25 317
点击上方Java后端，选择设为星标优质文章，及时送达作者 | 滴滴技术 出品| 滴滴技术作为卓越的一站式移动出行和生活平台，滴滴在亚洲、拉美和澳洲为超过5.5亿用户提供出租车、...
.net简历参考（工程师篇）
Huanzhucv的博客
07-28 347
成果：为整个公司甚至客户方提供数据安全查询，以及修改。独立负责数据源切换的设计实现、工作流的设计实现，整体采用工厂+策略模式+代理模式来是实现不同的数据源切换，以及不同的流程审批，为后期扩展不同的数据源及不同的工作流业务实现留下了扩展通道。对租户的项目进行了准确无误地授权，并通过定时作业的方式定期检查租户是否篡改授权信息，并通过运维将数据抽取到运营平台，对运营人员提供强有力的支持。参与租户平台以及运营平台开发，这两个项目都为SaaS产品的辅助设施项目，租户平台实现了租户的开户，运营平台实现了数据的运营。
设计模式之创建型模式（工厂、原型、建造者）
fengxiandada的博客
10-06 823
设计模式之创建者模式（工厂、原型、建造者）
spring-demo02-IOC-DI案例.zip
08-07
总之，"spring-demo02-IOC-DI案例"是一个很好的实践平台，帮助开发者深入理解并掌握Spring框架的核心特性，提高代码的可维护性和可扩展性。通过研究和实践这个案例，你将能够更好地应用这些知识到实际的项目开发中。
Spring5 框架 ---- IOC容器 ---- 代码
09-10
Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- IOC容器 ---- 代码 Spring5 框架 ---- ...
Spring-IoC-DI-main
02-11
标题“Spring-IoC-DI-main”提示我们讨论的核心是Spring框架中的两个核心特性：控制反转（Inversion of Control, IoC）和依赖注入（Dependency Injection, DI）。这两个概念是Java开发中的重要基石，尤其在构建大型...
Java-Spring-SpringIoC容器-SpringIoC的学习
10-11
在Java Spring框架中，Spring IoC（Inversion of Control，控制反转）是核心特性之一，它使得应用程序的组件之间的依赖关系不再由代码直接管理，而是交由Spring IoC容器负责。这种设计模式降低了代码间的耦合，提高...
maven-spring-ioc
08-07
Spring框架是Java开发中的一个核心组件，它提供了许多功能，其中最重要的一项就是Inversion of Control（IoC），也称为Dependency Injection（DI）。IoC容器是Spring的核心，它负责管理对象的生命周期和对象间的依赖...
【安全漏洞】SpringBoot + SpringSecurity CORS跨域资源共享配置
weixin_42925623的博客
09-05 1505
今天我们就来了解一下这个CROS漏洞，并记录一下在整合了springSecurity这一套安全框架下的springboot系统中如何在后端过滤器中通过正确注册WebMvcConfigurer bean来配置CORS的全局设置，实现对非白名单访问源的拦截。
SpringBoot总结
2302_77073236的博客
09-06 252
都做成图了，方便理解和掌握全局关系。
基于SpringBoot的多媒体信息共享平台开发
最新发布
qq_45800365的博客
09-06 234
基于SpringBoot的多媒体信息共享平台开发,java项目。eclipse和idea都能打开运行。推荐环境配置：eclipse/idea jdk1.8 maven mysql前端技术：vue，Ajax，Json后端技术：SpringBoot，MyBatis本系统共分为两个角色：管理员和用户。主要功能有:后台：系统首页个人中心用户管理作品分类管理作品信息管理私聊信息管理系统管理前台：首页作品信息公告信息后台管理个人中心。
【spring】微服务架构中的VO命名
突围
09-05 229
matchreqvo
MyBatis-Spring整合指南
它提供了与Spring的无缝对接，允许你在Spring的IoC容器中管理MyBatis的SqlSessionFactory和Mapper接口，简化事务管理和SqlSession的使用。 - 1.2.动机 MyBatis-Spring的出现是为了解决在Spring应用中使用MyBatis时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值