首页手记 JavaEE资料入门指南：简单教程详解

JavaEE资料入门指南：简单教程详解

标签：

Java Spring Cloud SSM

概述

本文全面介绍了JavaEE资料，涵盖了JavaEE的基本概念、开发环境搭建、基础技术和框架入门等内容。此外，还详细讲解了安全性教程和项目实战技巧，帮助读者快速掌握JavaEE开发技能。

JavaEE简介

JavaEE（Java Platform, Enterprise Edition）是一个由Oracle公司支持的企业级Java应用程序的开发平台。JavaEE旨在简化企业应用程序的开发、部署和管理过程，它提供了丰富的API和组件，使得开发者能够专注于业务逻辑的实现，而不是底层细节的处理。

什么是JavaEE

JavaEE是一种建立在JavaSE（标准版）之上的扩展技术，它不仅提供了标准的Java开发工具，还提供了针对企业级应用开发的额外功能。JavaEE定义了一系列接口和协议，允许开发者使用这些接口和协议构建大型、复杂的企业应用程序。这些应用程序通常需要处理大量的数据、复杂的业务逻辑、多用户访问、安全性等。

JavaEE的特点和优势

跨平台性：JavaEE应用程序可以在任何支持Java的平台上运行，如Windows、Linux、macOS等。
可扩展性：JavaEE提供了一套成熟的API和框架，允许开发者构建可扩展的应用程序。
安全性：JavaEE提供了多种安全机制，如SSL/TLS协议、认证与授权机制，可以确保企业应用程序的安全性。
多线程：JavaEE应用程序可以利用Java多线程特性，实现高效的并发处理。
易于维护：JavaEE应用程序采用分层架构和模块化设计，使得应用程序易于维护和升级。
支持多种数据库：JavaEE支持多种关系型和非关系型数据库，如MySQL、Oracle、MongoDB等。

JavaEE的核心技术和组件

JavaEE的核心技术和组件包括：

Java Servlet：Servlet是一种运行在服务器端的Java程序，用于接收客户端请求、处理请求，并生成响应。Servlet可以动态生成HTML或其他格式的内容，构建动态Web应用程序。
JavaServer Pages (JSP)：JSP是一种动态网页技术，它允许开发者在网页中嵌入Java代码，生成动态内容。JSP页面通常包含HTML代码和Java代码片段。
JavaServer Pages Standard Tag Library (JSTL)：JSTL是一个用于简化JSP开发的库，它提供了一组标签，使得开发者可以以更简洁的方式编写JSP页面。
Java Message Service (JMS)：JMS是一个客户端/服务器消息传递系统，它允许应用程序通过异步消息传递进行通信。
Java Naming and Directory Interface (JNDI)：JNDI提供了一种标准的接口，用于访问各种命名和目录服务。
Java Transaction API (JTA)：JTA提供了一种标准的接口，用于管理分布式事务。
Java Persistence API (JPA)：JPA是一个持久化API，它提供了一种标准的方式，用于将Java对象持久化到关系型数据库。

开发环境搭建

Java开发环境的安装

Java开发环境主要包括Java开发工具包（JDK）和Java运行环境（JRE）。

下载Java JDK：访问Oracle官方网站（https://www.oracle.com/java/technologies/javase-jdk11-downloads.html）下载对应版本的JDK。
安装Java JDK：按照安装向导完成JDK的安装。
配置环境变量：安装完成后，需要配置环境变量。设置JAVA_HOME指向JDK安装目录，设置PATH包含JAVA_HOME\bin。

# 设置JAVA_HOME
export JAVA_HOME=/path/to/jdk

# 设置PATH
export PATH=$JAVA_HOME/bin:$PATH

Tomcat服务器的安装与配置

Tomcat是一个开源的Java Servlet容器，用于运行JavaWeb应用程序。

下载Tomcat：访问Apache官方网站（http://tomcat.apache.org/）下载Tomcat。
安装Tomcat：将下载的Tomcat安装包解压到指定目录。
配置Tomcat：编辑conf/server.xml文件，配置服务器端口和其他参数。
启动Tomcat：在命令行中进入Tomcat安装目录，运行bin/startup.sh（Unix/Linux）或bin/startup.bat（Windows）启动Tomcat服务器。
停止Tomcat：运行bin/shutdown.sh（Unix/Linux）或bin/shutdown.bat（Windows）停止Tomcat服务器。

Eclipse或IntelliJ IDEA的使用入门

Eclipse

下载Eclipse：访问Eclipse官方网站（https://www.eclipse.org/downloads/）下载Eclipse。
安装Eclipse：解压下载的压缩包，启动Eclipse。
配置Eclipse：安装必要的插件，如Web开发插件、Java插件等。
新建项目：在Eclipse中新建JavaWeb项目，选择适当的项目类型。
运行项目：使用Eclipse内置的服务器或外部服务器运行项目。

<project>
    <name>MyWebApp</name>
    <type>JavaWeb</type>
    <servers>
        <server>
            <name>Tomcat</name>
            <url>http://localhost:8080</url>
        </server>
    </servers>
</project>

IntelliJ IDEA

下载IntelliJ IDEA：访问JetBrains官方网站（https://www.jetbrains.com/idea/）下载IntelliJ IDEA。
安装IntelliJ IDEA：解压下载的压缩包，启动IntelliJ IDEA。
配置IntelliJ IDEA：安装必要的插件，如Web开发插件、Java插件等。
新建项目：在IntelliJ IDEA中新建JavaWeb项目，选择适当的项目类型。
运行项目：使用IntelliJ IDEA内置的服务器或外部服务器运行项目。

<project>
    <name>MyWebApp</name>
    <type>JavaWeb</type>
    <servers>
        <server>
            <name>Tomcat</name>
            <url>http://localhost:8080</url>
        </server>
    </servers>
</project>

JavaEE基础技术学习

Servlet与JSP的使用方法

Servlet是Java EE中的一个核心组件，用于处理客户端请求和生成响应。JSP（JavaServer Pages）则是Servlet的一种扩展，它允许在HTML中嵌入Java代码，从而使得动态内容的生成更加方便。

Servlet

创建Servlet：创建一个继承自javax.servlet.http.HttpServlet的类。
处理请求：重写doGet或doPost方法，处理客户端请求。
生成响应：使用HttpServletResponse对象生成响应内容。

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HelloWorldServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        response.getWriter().println("<h1>Hello World</h1>");
    }
}

JSP

创建JSP页面：创建一个以.jsp为扩展名的文件。
嵌入Java代码：使用<% %>标签嵌入Java代码，生成动态内容。
使用JSP标签库：使用JSTL等标签库简化JSP开发。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>My JSP Page</title>
</head>
<body>
<% 
    String message = "Hello, JSP!";
%>
<h1><%= message %></h1>
</body>
</html>

JSTL的使用

JSTL（JavaServer Pages Standard Tag Library）是一个用于简化JSP开发的库，它提供了一组标签，使得开发者可以以更简洁的方式编写JSP页面。

引入JSTL标签库：在JSP页面中使用<%@ taglib %>标签引入JSTL标签库。
使用JSTL标签：使用<c:out>、<c:forEach>等标签进行动态内容的生成。
配置JSTL库：在web.xml文件中配置JSTL库。

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>My JSP Page</title>
</head>
<body>
<c:forEach items="${items}" var="item">
    <p><c:out value="${item}" /></p>
</c:forEach>
</body>
</html>

JavaEE框架入门

Spring框架简介及其在JavaEE中的应用

Spring是一个开源的Java应用程序框架，它提供了丰富的功能和工具，使得Java应用程序的开发变得更加简单和高效。Spring框架在JavaEE中的应用主要体现在以下几个方面：

控制反转（IoC）：通过依赖注入机制，Spring框架将对象的创建和管理移交给容器，使得应用程序更加灵活和可测试。
面向切面编程（AOP）：通过AOP技术，Spring框架可以将横切关注点（如日志、事务管理）与业务逻辑分离，使得代码更加清晰和模块化。
事务管理：Spring框架提供了声明式事务管理，通过注解或XML配置来管理事务。
Web开发：Spring框架提供了Spring MVC框架，用于构建Web应用程序。

Spring MVC框架

Spring MVC框架是Spring框架的一部分，用于构建Web应用程序。它基于MVC（Model-View-Controller）架构模式，将应用程序分为三个部分：模型（Model）、视图（View）和控制器（Controller）。

创建控制器：创建一个继承自org.springframework.web.servlet.mvc.Controller的类。
处理请求：重写handleRequest方法，处理客户端请求。
生成视图：返回一个ModelAndView对象，包含视图名称和模型数据。

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

public class HelloWorldController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("helloWorld");
        modelAndView.addObject("message", "Hello, Spring!");
        return modelAndView;
    }
}

Spring MVC项目实例

下面是一个简单的Spring MVC项目实例，包括控制器、视图和模型。

控制器：HelloWorldController.java

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class HelloWorldController {
    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    @ResponseBody
    public String helloWorld() {
        return "Hello, Spring!";
    }
}

视图：helloWorld.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Hello World</title>
</head>
<body>
<h1><%= request.getAttribute("message") %></h1>
</body>
</html>

配置文件：web.xml

<web-app>
    <display-name>Spring MVC Application</display-name>
    <servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
</web-app>

Hibernate框架简介及其在JavaEE中的应用

Hibernate是一个开源的Java持久化框架，它用于将Java对象持久化到关系型数据库中。Hibernate框架在JavaEE中的应用主要体现在以下几个方面：

对象关系映射（ORM）：通过对象关系映射技术，Hibernate框架将Java对象映射到数据库表，使得对象的持久化操作更加简单。
数据查询语言（HQL）：Hibernate框架提供了HQL语言，用于查询数据库中的数据。
事务管理：Hibernate框架提供了事务管理功能，通过注解或配置文件来管理事务。

Hibernate ORM

创建实体类：创建一个Java类，使用注解或XML配置文件表示数据库表结构。
配置Hibernate：在hibernate.cfg.xml文件中配置Hibernate连接信息。
持久化操作：使用Session对象进行对象的持久化操作，如save、delete等。

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private String email;

    // getters and setters
}

Hibernate项目实例

下面是一个简单的Hibernate项目实例，包括实体类、配置文件和持久化操作。

实体类：User.java

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private String email;

    // getters and setters
}

配置文件：hibernate.cfg.xml

<hibernate-configuration>
    <session-factory>
        <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="hibernate.connection.url">jdbc:mysql://localhost:3306/mydb</property>
        <property name="hibernate.connection.username">root</property>
        <property name="hibernate.connection.password">password</property>
        <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
        <property name="hibernate.hbm2ddl.auto">update</property>
    </session-factory>
</hibernate-configuration>

持久化操作：UserDAO.java

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

public class UserDAO {
    private SessionFactory sessionFactory;

    public UserDAO(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    public void saveUser(User user) {
        Session session = sessionFactory.openSession();
        Transaction transaction = session.beginTransaction();
        session.save(user);
        transaction.commit();
        session.close();
    }
}

面向服务的SOA架构介绍

面向服务的SOA（Service-Oriented Architecture）架构是一种软件架构模式，它将应用程序分解为一组独立的服务，这些服务可以相互协作来完成复杂的业务逻辑。SOA架构的特点包括：

服务独立性：每个服务都是一个独立的组件，可以独立部署、测试和维护。
服务互操作性：服务之间通过标准协议进行通信，如SOAP、REST等。
服务重用性：服务可以被多个应用程序重用，提高了开发效率和代码质量。

RESTful服务

创建RESTful服务：使用Spring框架或Jersey等框架创建RESTful服务。
定义资源：定义资源的URL路径和HTTP动词（GET、POST、PUT、DELETE）。
处理请求：使用注解或配置文件映射请求到相应的处理方法。

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {
    @GetMapping("/users")
    public List<User> getUsers() {
        // 查询用户列表
        return userRepository.findAll();
    }
}

SOA架构实例

下面是一个简单的SOA架构实例，包括服务接口和客户端调用。

服务接口：UserService.java

public interface UserService {
    List<User> getUsers();
}

服务实现：UserServiceImpl.java

import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

public class UserServiceImpl implements UserService {
    @PersistenceContext
    private EntityManager entityManager;

    @Override
    public List<User> getUsers() {
        return entityManager.createQuery("SELECT u FROM User u", User.class).getResultList();
    }
}

客户端调用：UserServiceClient.java

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserServiceClient {
    @Autowired
    private UserService userService;

    public void testUserService() {
        List<User> users = userService.getUsers();
        // 处理用户列表
    }
}

JavaEE安全性教程

用户认证与授权的基本概念

在JavaEE应用程序中，用户认证和授权是保护应用程序安全的重要组成部分。用户认证是指验证用户身份的过程，而用户授权则是指确定用户是否有权限访问特定资源的过程。

用户认证：用户认证通常通过用户名和密码、令牌、OAuth等方法实现。
用户授权：用户授权通常通过角色、权限等方法实现。

用户认证

创建认证过滤器：使用Spring Security或自定义过滤器实现用户认证。
配置认证机制：在web.xml文件中配置认证过滤器。
处理认证请求：在过滤器中处理认证请求，验证用户身份。

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class AuthenticationFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化过滤器
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;

        String username = httpRequest.getParameter("username");
        String password = httpRequest.getParameter("password");

        if (isAuthenticated(username, password)) {
            chain.doFilter(request, response);
        } else {
            httpResponse.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
        }
    }

    @Override
    public void destroy() {
        // 销毁过滤器
    }

    private boolean isAuthenticated(String username, String password) {
        // 验证用户身份
        return username.equals("admin") && password.equals("password");
    }
}

用户授权

创建授权过滤器：使用Spring Security或自定义过滤器实现用户授权。
配置授权机制：在web.xml文件中配置授权过滤器。
处理授权请求：在过滤器中处理授权请求，验证用户权限。

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class AuthorizationFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化过滤器
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        HttpServletResponse httpResponse = (HttpServletResponse) response;

        String username = httpRequest.getParameter("username");
        String resource = httpRequest.getRequestURI();

        if (isAuthorized(username, resource)) {
            chain.doFilter(request, response);
        } else {
            httpResponse.setStatus(HttpServletResponse.SC_FORBIDDEN);
        }
    }

    @Override
    public void destroy() {
        // 销毁过滤器
    }

    private boolean isAuthorized(String username, String resource) {
        // 验证用户权限
        return username.equals("admin") && (resource.equals("/admin") || resource.equals("/user"));
    }
}

Spring Security的认证与授权

创建认证提供者：使用UserDetailsService实现用户认证。
配置认证机制：在SecurityConfig类中配置认证提供者。
处理认证请求：在认证过滤器中处理认证请求。

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("admin")
            .password(passwordEncoder().encode("password"))
            .roles("ADMIN");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/admin").hasRole("ADMIN")
            .antMatchers("/user").hasRole("USER")
            .and()
            .formLogin();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

SSL/TLS在JavaEE中的应用

SSL/TLS协议是一种加密协议，用于保护网络通信的安全。JavaEE提供了多种方法来实现SSL/TLS的安全通信，如配置Tomcat服务器、使用HTTPS协议等。

配置Tomcat服务器：在server.xml文件中配置SSL/TLS证书。
使用HTTPS协议：在应用程序中使用HTTPS协议，实现客户端与服务器之间的安全通信。

<Connector port="8443" protocol="HTTP/1.1"
           SSLEnabled="true"
           maxThreads="150"
           scheme="https"
           secure="true"
           clientAuth="false"
           sslProtocol="TLS"
           keystoreFile="/path/to/keystore"
           keystorePass="password" />

JavaEE项目实战

创建简单的JavaWeb应用

创建一个简单的JavaWeb应用，包括创建Web应用程序、配置服务器、编写Servlet和JSP页面。

创建Web应用程序：使用Eclipse或IntelliJ IDEA创建一个JavaWeb项目，选择适当的项目类型。
配置服务器：在Eclipse或IntelliJ IDEA中配置Tomcat服务器。
编写Servlet：创建一个Servlet，处理客户端请求并生成响应。
编写JSP页面：创建一个JSP页面，生成动态内容。
运行项目：启动Tomcat服务器，访问浏览器查看应用效果。

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HelloWorldServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        response.getWriter().println("<h1>Hello World</h1>");
    }
}

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>My JSP Page</title>
</head>
<body>
<h1>Hello, JSP!</h1>
</body>
</html>

使用JavaEE技术构建企业级应用实例

构建一个企业级应用实例，包括创建数据库、编写持久化层、服务层、控制器层，以及配置安全机制。

创建数据库：使用MySQL或其他数据库创建数据库和表。
编写持久化层：使用Hibernate或JPA实现对象的持久化操作。
编写服务层：实现业务逻辑，如用户认证、授权等。
编写控制器层：实现HTTP请求的处理，返回视图或数据。
配置安全机制：使用Spring Security或其他安全框架实现安全机制。

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Entity
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private int id;
    private String name;
    private String email;

    // getters and setters
}

import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(AuthenticationManagerBuilder auth) throws Exception {
        auth.inMemoryAuthentication()
            .withUser("admin")
            .password(passwordEncoder().encode("password"))
            .roles("ADMIN");
    }

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.authorizeRequests()
            .antMatchers("/admin").hasRole("ADMIN")
            .antMatchers("/user").hasRole("USER")
            .and()
            .formLogin();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

项目部署与调试技巧

部署和调试JavaEE项目需要了解一些基本的技巧，如配置服务器、调试代码、查看日志等。

配置服务器：在Eclipse或IntelliJ IDEA中配置Tomcat或其他服务器。
调试代码：使用IDE的调试工具，设置断点、查看变量等。
查看日志：查看服务器日志文件，解决运行时错误。

<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-core</artifactId>
    <version>2.14.1</version>
</dependency>

log4j.rootLogger=DEBUG, stdout, file

log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

log4j.appender.file=org.apache.log4j.DailyRollingFileAppender
log4j.appender.file.File=log/app.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

以上是JavaEE入门指南的详细内容，涵盖了JavaEE的基本概念、开发环境搭建、基础技术学习、框架入门、安全性教程、项目实战等内容。希望读者能通过本指南，快速掌握JavaEE开发的基本技能，并能够构建出高质量的企业级应用。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

慕婉清6462132

手记
篇

粉丝

14

获赞与收藏

86

关注作者，订阅最新文章

阅读免费教程

Java并发工具

23个小节 19367 315

Java 并发原理入门教程

26个小节 39106 568

Java 入门教程

50个小节 342495 3164

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空