初学spring之入门案列

最新推荐文章于 2024-09-09 11:33:34 发布
最新推荐文章于 2024-09-09 11:33:34 发布
阅读量58 收藏
点赞数
文章标签： 开发工具 java
原文链接：http://www.cnblogs.com/bdqnquliang/p/7235837.html
版权

spring其实是一个很大的开源框架,而我学的就是spring framework,这只是spring其中的一小部分.有疑惑的可以去官网去看看,spring官网我就不提供了.一百度肯定有.和spring framework并行的有,这是一个网站,你们可以看看:

http://blog.csdn.net/hjd_love_zzt/article/details/12966273

需要的jar包节点如下: 

 1 <dependency>
 2             <groupId>org.springframework</groupId>
 3             <artifactId>spring-beans</artifactId>
 4             <version>4.3.9.RELEASE</version>
 5         </dependency>
 6         <dependency>
 7             <groupId> org.aspectj</groupId >
 8             <artifactId> aspectjweaver</artifactId >
 9             <version> 1.8.7</version>
10         </dependency>
11         <dependency>
12             <groupId>org.springframework</groupId>
13             <artifactId>spring-context</artifactId>
14             <version>4.3.9.RELEASE</version>
15         </dependency>
16         <dependency>

今天我敲的几个相对比较简单的列子:

1.例子一：

实体类如下:

 1 package cn.ql.spring01; /**
 2  * Created by 123 on 2017/07/24.
 3  */
 4 
 5 /**
 6  * \* Created with IntelliJ IDEA.
 7  * \* User: 123
 8  * \* Date: 2017/07/24
 9  * \* Time: 09:26
10  * \* To change this template use File | Settings | File Templates.
11  * \* Description:
12  * \
13  */
14 public class SomeService {
15     private String info;
16 
17     public String getInfo() {
18         return info;
19     }
20 
21     public void setInfo(String info) {
22         this.info = info;
23     }
24 
25     public void work() {
26         System.out.println("Hello" + info);
27     }
28 }

下面这是配置文件:

1 <!--  第一个spring例子  -->
2     <bean id="someService" class="cn.ql.spring01.SomeService">
3     </bean>

这是测试类:

 1 package cn.ql.spring01;/**
 2  * Created by 123 on 2017/07/24.
 3  */
 4 
 5 import org.junit.Test;
 6 import org.springframework.context.ApplicationContext;
 7 import org.springframework.context.support.ClassPathXmlApplicationContext;
 8 /**
 9  * \* Created with IntelliJ IDEA.
10  * \* User: 123
11  * \* Date: 2017/07/24
12  * \* Time: 09:31
13  * \* To change this template use File | Settings | File Templates.
14  * \* Description:
15  * \
16  */
17 public class TestSomeService {
18 
19     @Test
20     public void TestSomeService() {
21         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
22         SomeService someService = (SomeService)ctx.getBean("someService");
23 
24         someService.setInfo("spring");
25 
26         someService.work();
27     }
28 }

 

 

2.例子二（域属性，简称复杂属性,说简单点就是在一个对象实体类中植入另外一个对象实体=========注,所以需要两个对象）

实体类如下:

Car实体类

 1 package cn.ql.spring02;/**
 2  * Created by 123 on 2017/07/24.
 3  */
 4 
 5 /**
 6  * \* Created with IntelliJ IDEA.
 7  * \* User: 123
 8  * \* Date: 2017/07/24
 9  * \* Time: 10:17
10  * \* To change this template use File | Settings | File Templates.
11  * \* Description:
12  * \
13  */
14 public class Car {
15     private String brand;
16     private String color;
17 
18     @Override
19     public String toString() {
20         return "Car{" +
21                 "brand='" + brand + '\'' +
22                 ", color='" + color + '\'' +
23                 '}';
24     }
25 
26     public String getColor() {
27         return color;
28     }
29 
30     public void setColor(String color) {
31         this.color = color;
32     }
33 
34     public String getBrand() {
35         return brand;
36     }
37 
38     public void setBrand(String brand) {
39         this.brand = brand;
40     }
41 }

 Student实体类

 1 package cn.ql.spring02;/**
 2  * Created by 123 on 2017/07/24.
 3  */
 4 
 5 /**
 6  * \* Created with IntelliJ IDEA.
 7  * \* User: 123
 8  * \* Date: 2017/07/24
 9  * \* Time: 10:20
10  * \* To change this template use File | Settings | File Templates.
11  * \* Description:
12  * \
13  */
14 public class Student {
15     private String name;
16     private int age;
17 
18     private Car car;    //植入Car类型的复杂对象
19 
20     public Car getCar() {
21         return car;
22     }
23 
24     public void setCar(Car car) {
25         this.car = car;
26     }
27 
28     @Override
29     public String toString() {
30         return "Student{" +
31                 "name='" + name + '\'' +
32                 ", age=" + age +
33                 ", car=" + car +
34                 '}';
35     }
36 
37     public String getName() {
38         return name;
39     }
40 
41     public void setName(String name) {
42         this.name = name;
43     }
44 
45     public int getAge() {
46         return age;
47     }
48 
49     public void setAge(int age) {
50         this.age = age;
51     }
52 }

 

配置文件如下:

 1 <!--第二个spring例子-->
 2     <bean id="car" class="cn.ql.spring02.Car">
 3         <property name="brand" value="兰博基尼"></property>
 4         <property name="color" value="绿色"></property>
 5     </bean>
 6 
 7     <bean id="student" class="cn.ql.spring02.Student">
 8         <property name="name" value="大哥"></property>
 9         <property name="age" value="3"></property>
10         <property name="car" ref="car"></property>
11     </bean>

 

测试类如下:

 1 package cn.ql.spring01;/**
 2  * Created by 123 on 2017/07/24.
 3  */
 4 
 5 import cn.ql.spring01.SomeService;
 6 import cn.ql.spring02.Student;
 7 import org.junit.Test;
 8 import org.springframework.context.ApplicationContext;
 9 import org.springframework.context.support.ClassPathXmlApplicationContext;
10 
11 /**
12  * \* Created with IntelliJ IDEA.
13  * \* User: 123
14  * \* Date: 2017/07/24
15  * \* Time: 09:31
16  * \* To change this template use File | Settings | File Templates.
17  * \* Description:
18  * \
19  */
20 public class TestCarAndStudent {
21 
22     @Test
23     public void TestCarAndStudent() {
24         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
25         Student stu = (Student) ctx.getBean("student");
26         System.out.println(stu);
27     }
28 }

也是没啥问题的.

 

3.例子三(打印机案例)

墨水接口

 1 package cn.ql.spring03;
 2 
 3 /**
 4  * Created by 123 on 2017/07/24.
 5  */
 6 //墨水接口
 7 public interface Ink {
 8     //获取颜色的方法
 9     public String getColor();
10 }

纸张接口

 1 package cn.ql.spring03;
 2 
 3 /**
 4  * Created by 123 on 2017/07/24.
 5  */
 6 //纸张接口
 7 public interface Paper {
 8     //获取类型纸张的方法
 9     public String getPage();
10 }

彩色墨水实现类

 1 package cn.ql.spring03;/**
 2  * Created by 123 on 2017/07/24.
 3  */
 4 
 5 /**
 6  * \* Created with IntelliJ IDEA.
 7  * \* User: 123
 8  * \* Date: 2017/07/24
 9  * \* Time: 10:36
10  * \* To change this template use File | Settings | File Templates.
11  * \* Description:
12  * \
13  */
14 
15 //墨水的实现类    彩色墨水
16 public class ColorInk implements Ink {
17     @Override
18     public String getColor() {
19         return "彩色";
20     }
21 }

灰色墨水实现类

 1 package cn.ql.spring03;/**
 2  * Created by 123 on 2017/07/24.
 3  */
 4 
 5 /**
 6  * \* Created with IntelliJ IDEA.
 7  * \* User: 123
 8  * \* Date: 2017/07/24
 9  * \* Time: 10:36
10  * \* To change this template use File | Settings | File Templates.
11  * \* Description:
12  * \
13  */
14 墨水的实现类    灰色墨水
15 public class GrayInk implements Ink {
16     @Override
17     public String getColor() {
18         return "灰色";
19     }
20 }

A4纸张实现类

 1 package cn.ql.spring03;/**
 2  * Created by 123 on 2017/07/24.
 3  */
 4 
 5 /**
 6  * \* Created with IntelliJ IDEA.
 7  * \* User: 123
 8  * \* Date: 2017/07/24
 9  * \* Time: 10:39
10  * \* To change this template use File | Settings | File Templates.
11  * \* Description:
12  * \
13  */
14 
15 //纸张的实现类    A4纸张
16 public class A4Paper implements Paper {
17     @Override
18     public String getPage() {
19         return "我是一张A4纸";
20     }
21 }

B5纸张实现类

package cn.ql.spring03;/**
 * Created by 123 on 2017/07/24.
 */

/**
 * \* Created with IntelliJ IDEA.
 * \* User: 123
 * \* Date: 2017/07/24
 * \* Time: 10:40
 * \* To change this template use File | Settings | File Templates.
 * \* Description:
 * \
 */
//纸张的实现类    B5纸张
public class B5Paper implements Paper {
    @Override
    public String getPage() {
        return "我是一张B5纸";
    }
}

打印机实体类(其实就是植入两个复杂类型的对象)

 

 1 package cn.ql.spring03;/**
 2  * Created by 123 on 2017/07/24.
 3  */
 4 
 5 /**
 6  * \* Created with IntelliJ IDEA.
 7  * \* User: 123
 8  * \* Date: 2017/07/24
 9  * \* Time: 10:42
10  * \* To change this template use File | Settings | File Templates.
11  * \* Description:
12  * \
13  */
14 public class Print {
15     //植入两个复杂类型的对象
16     private Ink ink;
17     private Paper paper;
18 
19     public Ink getInk() {
20         return ink;
21     }
22 
23     public void setInk(Ink ink) {
24         this.ink = ink;
25     }
26 
27 
28     //因为方便我获取颜色和类型纸张,所以直接就调用了复杂类型的get方法
29     @Override
30     public String toString() {
31         return "Print{" +
32                 "ink=" + ink.getColor() +
33                 ", paper=" + paper.getPage() +
34                 '}';
35     }
36 
37     public Paper getPaper() {
38         return paper;
39     }
40 
41     public void setPaper(Paper paper) {
42         this.paper = paper;
43     }
44 }

配置文件

1 <!--第三个spring例子 -->
2     <bean id="a4Paper" class="cn.ql.spring03.A4Paper"></bean>
3     <bean id="colorInk" class="cn.ql.spring03.ColorInk"></bean>
4 
5     <bean id="print" class="cn.ql.spring03.Print">
6         <property name="ink" ref="colorInk"></property>     <!--ref可以说是间接调用了colorInkk的id的实现类-->
7         <property name="paper" ref="a4Paper"></property>    <!---->
8     </bean>

测试类如下:

 1 package cn.ql.spring01;/**
 2  * Created by 123 on 2017/07/24.
 3  */
 4 
 5 import cn.ql.spring03.Print;
 6 import org.junit.Test;
 7 import org.springframework.context.ApplicationContext;
 8 import org.springframework.context.support.ClassPathXmlApplicationContext;
 9 
10 import java.applet.AppletContext;
11 
12 /**
13  * \* Created with IntelliJ IDEA.
14  * \* User: 123
15  * \* Date: 2017/07/24
16  * \* Time: 11:35
17  * \* To change this template use File | Settings | File Templates.
18  * \* Description:
19  * \
20  */
21 public class TestPrint {
22 
23     @Test
24     public void Testprint() {
25         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
26         Print print = (Print) ctx.getBean("print");
27         //其实在这里调用也是没啥问题的
28         System.out.println(print);
29     }
30 }

 

4.例子四(spring之AOP概念,这个例子对于新手来说还是有难度的,所以我就把这个例子的目录结构贴出来)

红色标记的都是我这个案例使用到的类.

dao层:

package cn.ql.springAOP04.dao;

import cn.ql.springAOP04.entity.User;

/**
 * Created by 123 on 2017/07/24.
 */
//用户的接口
public interface IUserDAO {
    //保存用户
    public void save(User user);
}

实现类:

package cn.ql.springAOP04.dao;/**
 * Created by 123 on 2017/07/24.
 */

import cn.ql.springAOP04.entity.User;

/**
 * \* Created with IntelliJ IDEA.
 * \* User: 123
 * \* Date: 2017/07/24
 * \* Time: 12:04
 * \* To change this template use File | Settings | File Templates.
 * \* Description:
 * \
 */
//实现类
public class UserDAOImpl implements IUserDAO {
    public void save(User user) {
        System.out.println("save  success");
    }
}

实体类:

package cn.ql.springAOP04.entity;/**
 * Created by 123 on 2017/07/24.
 */

/**
 * \* Created with IntelliJ IDEA.
 * \* User: 123
 * \* Date: 2017/07/24
 * \* Time: 12:03
 * \* To change this template use File | Settings | File Templates.
 * \* Description:
 * \
 */
//用户实体类
public class User {
    private String name;
    private String eamil;

    public String getName() {
        return name;
    }

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

    public String getEamil() {
        return eamil;
    }

    public void setEamil(String eamil) {
        this.eamil = eamil;
    }
}

service层:

 1 package cn.ql.springAOP04.service;
 2 
 3 import cn.ql.springAOP04.entity.User;
 4 
 5 /**
 6  * Created by 123 on 2017/07/24.
 7  */
 8 public interface IUserService {
 9     public void save(User user);
10 }

UserServiceImpl类

 1 package cn.ql.springAOP04.service;/**
 2  * Created by 123 on 2017/07/24.
 3  */
 4 
 5 import cn.ql.springAOP04.dao.IUserDAO;
 6 import cn.ql.springAOP04.dao.UserDAOImpl;
 7 import cn.ql.springAOP04.entity.User;
 8 
 9 /**
10  * \* Created with IntelliJ IDEA.
11  * \* User: 123
12  * \* Date: 2017/07/24
13  * \* Time: 12:07
14  * \* To change this template use File | Settings | File Templates.
15  * \* Description:
16  * \
17  */
18 public class UserServiceImpl implements IUserService {
19 
20 
21     private IUserDAO dao;
22 
23     public IUserDAO getImpl() {
24         return dao;
25     }
26 
27     public void setImpl(IUserDAO dao) {
28         this.dao = dao;
29     }
30 
31     @Override
32     public void save(User user) {
33         dao.save(user);
34     }
35 }

AOP层(我只是测试了一下前置增强方法,大家有兴趣的,可以试试其他的):

 1 package cn.ql.springAOP04.aop;/**
 2  * Created by 123 on 2017/07/24.
 3  */
 4 
 5 import org.springframework.aop.MethodBeforeAdvice;
 6 
 7 import java.lang.reflect.Method;
 8 
 9 /**
10  * \* Created with IntelliJ IDEA.
11  * \* User: 123
12  * \* Date: 2017/07/24
13  * \* Time: 12:11
14  * \* To change this template use File | Settings | File Templates.
15  * \* Description:
16  * \
17  */
18 //前置增强类
19 public class LoggerBeforeAdvice implements MethodBeforeAdvice {
20     @Override
21     public void before(Method method, Object[] objects, Object o) throws Throwable {
22         System.out.println("========================记录日志");
23     }
24 }

配置文件(这个配置相对来说是比较多的,不懂得,可以去看看下面的注释):

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <beans xmlns="http://www.springframework.org/schema/beans"
 3        xmlns:aop="http://www.springframework.org/schema/aop"
 4        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 5 
 6        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
 7         http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
 8 ">
 9     <!--1.配置dao层    只能是实现类,不是接口-->
10     <bean id="userDAO" class="cn.ql.springAOP04.dao.UserDAOImpl"></bean>
11 
12     <!--2.service 植入对象-->
13     <bean id="userService" class="cn.ql.springAOP04.service.UserServiceImpl">
14         <property name="impl" ref="userDAO"></property>
15     </bean>
16 
17     <!--3 通知  advice:增强-->
18     <bean id="loggerBefore" class="cn.ql.springAOP04.aop.LoggerBeforeAdvice"></bean>
19 
20     <aop:config>
21         <!--配置切点  expression表达式      execution需要拦截的类   -->
22         <aop:pointcut id="mypointcut"
23                       expression="execution(public void cn.ql.springAOP04.service.UserServiceImpl.save(cn.ql.springAOP04.entity.User))"></aop:pointcut>
24 
25         <!--织入   advice-ref   相当于引用loggerBefore      pointcut-ref  引用了mypointcut      -->
26         <aop:advisor advice-ref="loggerBefore" pointcut-ref="mypointcut"></aop:advisor>
27     </aop:config>
28 
29 </beans>

测试类:

 1 package cn.ql.spring01;/**
 2  * Created by 123 on 2017/07/24.
 3  */
 4 
 5 import cn.ql.springAOP04.entity.User;
 6 import cn.ql.springAOP04.service.IUserService;
 7 import cn.ql.springAOP04.service.UserServiceImpl;
 8 import org.junit.Test;
 9 import org.springframework.context.ApplicationContext;
10 import org.springframework.context.support.ClassPathXmlApplicationContext;
11 
12 /**
13  * \* Created with IntelliJ IDEA.
14  * \* User: 123
15  * \* Date: 2017/07/24
16  * \* Time: 12:28
17  * \* To change this template use File | Settings | File Templates.
18  * \* Description:
19  * \
20  */
21 public class TestAOP04 {
22 
23     @Test
24     public void testAOP04() {
25         ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContextAop.xml");
26         IUserService service = (IUserService) ctx.getBean("userService");
27         User user = new User();
28         service.save(user);
29 
30     }
31 
32 }

其实吧,我感觉就是最后一个例子,有些难度,其余的还好.我感觉AOP编程,以我的理解就是把相同的步骤变得简易化.或者从某种程度上来说,就是使程序更健壮,同时也提高了编码的质量,可能我所理解的AOP思想还远远不够,这只是个人见解.

转载于:https://www.cnblogs.com/bdqnquliang/p/7235837.html

weixin_30363817
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring入门篇
github_38596081的博客
01-04 332
第1章 概述 本章对课程的情况进行介绍，并介绍框架和Spring概况。 1-1 Spring入门课程简介 (05:56) 1-2 Spring概况 (09:39) 1-3 Spring框架 (04:24) 第2章 Spring IOC容器 介绍Spring IOC容器的基本概念和应用 2-1 IOC及Bean容器 (20:18) 容器中的对象就是Bean 使用Bea...
Spring入门
了凡
05-31 886
Spring入门Spring是一个轻量级控制反转(Ioc)和面向切面(AOP)的容器框架，它主要是为解决企业应用开发的复杂性而诞生的IoCIoC(Inversion of Control，控制反转)，就是由spring来负责控制对象的生命周期和对象间的关系。 IoC的另外的名字叫做依赖注入(Dependency Injection) 从注入方法上看，主要划分为三种类型： 构造函数注入： 通过调用
玩转Spring Boot框架教程02之入门程序
itcodeschool的博客
05-31 491
二、Spring Boot入门：2.1环境要求 JDK1.7或以上 Maven环境搭建开发工具：1）  Eclipse中安装STS插件2）  使用idea工具3）  下载Spring ToolSuite简称STSsts是一个定制版的Eclipse，专为Spring开发定制的，方便创建调试运行维护Spring应用。本教程采用Srping Tool Suite下载地址：http://spring.io...
02.Mybatis入门案例
Clawww的学习笔记
02-28 201
1.mybatis的入门 首先我们需要配置一下log4j.properties文件 代码如下,直接放进resource文件里就可以. # Set root category priority to INFO and its only appender to CONSOLE. #log4j.rootCategory=INFO, CONSOLE d...
CXF与Spring整合的入门案列（优化最小的lib）
10-26
本文将深入探讨如何实现CXF与Spring的整合，并提供一个最小化的依赖包配置案例，帮助初学者快速入门。 首先，CXF（Apache CXF）是一个开源的Java框架，主要用于构建和开发SOAP和RESTful Web服务。它提供了丰富的API...
Spring初学者入门教程 PDF带书签高清版
11-06
Spring框架是Java开发中最受欢迎的轻量级框架之一，它为构建企业级应用程序提供了全面的解决方案。本教程针对初学者，旨在帮助他们快速掌握Spring框架的基础知识和核心概念。 Spring框架的核心特性包括依赖注入...
初学spring项目(入门解读和新建项目)
04-08
这篇博文“初学Spring项目(入门解读和新建项目)”将带你逐步走进Spring的世界，了解如何从零开始搭建一个Spring项目。 首先，让我们了解一下Spring的核心概念。Spring框架的核心包括依赖注入（Dependency Injection...
springDemo初学入门
10-11
"springDemo初学入门"这个主题旨在引导初学者掌握Spring框架的基本用法。在这个压缩包中，可能包含了一个简单的Spring项目实例——myWebProject，这是一个基础的Web项目，用于演示Spring的核心功能。 1. **Spring...
Spring框架入门
weixin_44279647的博客
08-23 2980
1.Spring框架是什么 Spring是一个轻量级的控制反转（IOC）和面向切面（AOP）的容器框架 1.什么时IOC IOC(inversion of control 控制反转)，控制反转（IOC）与依赖注入（DI）是同一个概念 具体的讲：当某个对象需要调用另一个对象，在传统的程序设计过程中，通常由调用者来创建被调用者的实例，但是在spring中使用了工厂设计模式，为我们创建了所需要的对象，直接调用spring提供的对象就可以了。 引入IOC的目的： 脱开，降低类之间的耦合； 倡导面向接
vi与vim编辑器
youhebuke225的博客
09-05 864
vi（Visual editor）是最原始的文本编辑器之一，由Bill Joy在1970年代末期为Berkeley Unix开发。vi命令模式（Command mode）：这是启动vi时的默认模式。在此模式下，用户可以输入命令来编辑文本，如删除行、复制行等。插入模式（Insert mode）：在此模式下，用户可以输入文本。进入此模式的方式是从命令模式中输入iao等命令。末行模式（Last line mode）：在此模式下，用户可以输入命令来保存文件、退出编辑器等。进入此模式的方式是从命令模式中输入冒号。
软件著作权申请教程（超详细）（2024新版）软著申请
m0_75269526的博客
09-09 1132
软件著作权，软著，软著申请，软用户使用手册：提交登记软件的任何一种文档的连续的前30页和连续的后30页，每页不少于30行。如果是多人合作开发著作权人不是一个人的话，还需要准备一份合作开发协议。首先我们需要在官网里面注册一个账号，并且完成实名认证，一般是注册【个人】的身份。合作开发协议书：这个如果是著作权人有多个（多个人一起开发）就需要提供这个材料。在填报完成之后需要打印一个签章页签字（如果不是个人需要盖章）注册完成后点击下面进行登记，如果没有实名需要先实名认证（源代码：源程序前连续的30页和后连续的30页。
html+css网页设计 大话西游7个页面 带报告
qq_42431718的博客
09-04 339
html+css网页设计 大话西游7个页面 带报告 网页作品代码简单，可使用任意HTML编辑软件（如：Dreamweaver、HBuilder、Vscode 、Sublime 、Webstorm、Text 、Notepad++ 等任意html编辑软件进行运行及修改编辑等操作）。
在VScode上写网页（html）
2302_80978287的博客
09-07 289
把代码复制粘贴进去，然后点击文件→另存为→选择html格式。
运维学习————Jenkins(1)
m0_73376570的博客
09-05 1268
作为领先的开源自动化服务器，Jenkins 提供了数百个插件来支持构建、部署和自动化任何项目。构建伟大，无所不能。Jenkins是开源CI(持续集成Continuous Integration)&CD（持续开发Continuous deployment）软件领导者， 提供超过1000个插件来支持构建、部署、自动化， 满足任何项目的部署需要（如何把我们项目部署到测试或者生产环境技术）。
关于Vscode的vscode-cpptools中的icph占用c盘内存过大问题
ros275229的博客
09-06 264
关于Vscode的vscode-cpptools中的icph占用c盘内存过大问题
AI环境初识
海鸥
09-06 477
在搭建AI环境时，当前流行的技术涉及多个方面，包括开发框架、深度学习库、硬件支持以及具体的应用技术等。
Jupyter管理内核命令
最新发布
bitcarmanlee的博客
09-09 133
在虚拟环境中安装ipykernel包。然后安装ipykernel包。
anaconda启动jupyter notebook
带着问题学技术的博客
09-08 274
1.在Windows搜索框搜索anaconda prompt点击打开。2.然后输入命令jupyter notebook。3.在这个页面编写你的程序。
Spring框架入门：分层架构与核心模块详解
本文是Spring框架入门系列的第一部分，着重介绍了框架的基本概念和关键模块。 首先，我们从底层模型出发，Spring的核心是其核心容器，即BeanFactory，它基于工厂模式，实现了控制反转（IoC，Inversion of Control）...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值