Essential Slick 3滑块库基础教程

5星 · 超过95%的资源需积分: 10 194 浏览量更新于2024-07-20 收藏 643KB PDF 举报

《Essential Slick 3》是由Richard Dallaway和Jonathan Ferguson合作编著的一本关于Slick库的教程书籍，该库是Scala中用于创建高性能、易用的UI组件的工具。Slick-3版本是在2015年发布，专为Scala开发者设计，旨在帮助他们更高效地构建用户界面，并提升开发体验。本书由Underscore Consulting LLP出版，位于英国Brighton，提供团队折扣，并可通过网站<http:///underscore.io/training>获取更多资源和优惠信息。在阅读过程中，作者鼓励读者联系hello@underscore.io进行咨询，以获取与文本相关的更多信息。此外，尽管作者和出版社已尽力确保内容的准确性，但书中提供的所有信息（包括编程代码）仅供参考，不承担因使用书中的内容导致的错误、遗漏或由此产生的任何损害的责任。本书的结构包括： **1. Preface** - 引言部分，可能介绍了写作背景、目标读者和书籍的目的，以及对于理解和使用Slick-3的必要性。 **2. How to Contact Us** - 提供了作者团队的联系方式，以便读者遇到问题时寻求支持。 **3. Acknowledgements** - 感谢那些对编写本书做出贡献的人，可能包括合作者、技术支持、审稿人等。 **4. Conventions Used in This Book** - 介绍本书中使用的特定术语、符号和约定，有助于读者一致理解内容。 **5. Typographical Conventions** - 关于字体样式、代码样例和强调元素的规定，帮助读者在阅读时准确识别不同类型的信息。 **6. Source Code** - 提供实际的Slick-3代码示例，读者可以通过这些代码深入了解库的用法和功能。 **7. Callout Boxes** - 可能包含额外的提示、技巧或重要信息，以补充正文内容，帮助读者深入学习。 **1. Basics** - 第一部分，从基础概念开始，讲解如何在Scala项目中设置和导入Slick-3库，以及如何定义和操作数据库查询。 **1.1 O"** - 这部分具体可能会介绍Slick-3中的对象关系映射（Object-Relational Mapping, ORM）概念，如何将数据库表映射到Scala类，以及基本的查询构造和执行方法。随着章节的深入，内容会逐渐涵盖数据访问模式、高级查询技巧、性能优化和最佳实践等主题，确保读者能够掌握Slick-3库的核心功能，并在实际项目中熟练运用。通过阅读这本书，Scala开发者可以提升其前端开发效率和UI构建能力。

16 CHAPTER 1. BASICS

the pros and cons of ORMs here, but if this is an area that interests you, take a look at the Coming from

ORM to Slick arcle in the Slick manual.

If you aren’t familiar with ORMs, congratulaons. You already have one less thing to worry about!

1.2 Running the Examples and Exercises

The aim of this ﬁrst chapter is to provide a high-level overview of the core concepts involved in Slick, and get

you up and running with a simple end-to-end example. You can grab this example now by cloning the Git repo

of exercises for this book:

bash$ git clone git@github.com:underscoreio/essential-slick-code.git

Cloning into 'essential-slick-code'...

bash$ cd essential-slick-code

bash$ ls -1

README.md

chapter-01

chapter-02

chapter-03

chapter-04

chapter-05

chapter-06

chapter-07

Each chapter of the book is associated with a separate sbt project that provides a combinaon of examples and

exercises. We’ve bundled everything you need to run sbt in the directory for each chapter.

We’ll be using a running example of a chat applicaon similar to Slack, Gier, or IRC. The app will grow and

evolve as we proceed through the book. By the end it will have users, messages, and rooms, all modelled using

tables, relaonships, and queries.

For now, we will start with a simple conversaon between two famous celebries. Change to the chapter-01

directory now, use the sbt.sh script to start sbt, and compile and run the example to see what happens:

bash$ cd chapter-01

bash$ ./sbt.sh

# sbt log messages...

> compile

# More sbt log messages...

> run

Creating database table

Inserting test data

Selecting all messages:

Message("Dave","Hello, HAL. Do you read me, HAL?",1)

Message("HAL","Affirmative, Dave. I read you.",2)

Message("Dave","Open the pod bay doors, HAL.",3)

1.3. WORKING INTERACTIVELY IN THE SBT CONSOLE 17

Message("HAL","I'm sorry, Dave. I'm afraid I can't do that.",4)

Selecting only messages from HAL:

Message("HAL","Affirmative, Dave. I read you.",2)

Message("HAL","I'm sorry, Dave. I'm afraid I can't do that.",4)

If you get output similar to the above, congratulaons! You’re all set up and ready to run with the examples and

exercises throughout the rest of this book. If you encounter any errors, let us know on our Gier channel and

we’ll do what we can to help out.

Tip

New to sbt?

The ﬁrst me you run sbt, it will download a lot of library dependencies from the Internet and cache them

on your hard drive. This means two things:

• you need a working Internet connecon to get started; and

• the ﬁrst compile command you issue could take a while to complete.

If you haven’t used sbt before, you may ﬁnd the sbt Tutorial useful.

1.3 Working Interacvely in the sbt Console

To get you up to speed quickly, we’ve created an exec method and imported the base requirements to run

examples from the console. You can see this by starng sbt and then running the console command. Which

will give output similar to:

> console

[info] Compiling 1 Scala source to /Users/jonoabroad/developer/books/ ↩

essential-slick-code/chapter-01/target/scala-2.11/classes...

[info] Starting scala interpreter...

[info]

import slick.driver.H2Driver.api._

import Example._

import scala.concurrent.duration._

import scala.concurrent.Await

import scala.concurrent.ExecutionContext.Implicits.global

db: slick.driver.H2Driver.backend.Database =

slick.jdbc.JdbcBackend$DatabaseDef@75028b56 ↩

exec: [T](program: slick.driver.H2Driver.api.DBIO[T])T

res0: Option[Int] = Some(4)

Welcome to Scala version 2.11.7 (Java HotSpot(TM) 64-Bit Server VM, ↩

Java 1.8.0_25).

Type in expressions to have them evaluated.

Type :help for more information.

scala>

This means we can focus on Slick, rather than the boilerplate. There is a complete explanaon of exec later in

the chapter. For now, a small example showing its usuage and output:

1.4. EXAMPLE: A SEQUEL ODYSSEY 19

• a logging library.

If we were using a separate database like MySQL or PostgreSQL, we would substute the H2 dependency for

the JDBC driver for that database.

1.4.2 Imporng Library Code

Database management systems are not created equal. Diﬀerent systems support diﬀerent data types, diﬀerent

dialects of SQL, and diﬀerent querying capabilies. To model these capabilies in a way that can be checked at

compile me, Slick provides most of its API via a database-speciﬁc driver. For example, we access most of the

Slick API for H2 via the following import:

import slick.driver.H2Driver.api._

Slick makes heavy use of implicit conversions and extension methods, so we generally need to include this

import anywhere where we’re working with queries or the database. Chapter 5 looks how you can keep a

speciﬁc database driver out of your code unl necessary.

1.4.3 Deﬁning our Schema

Our ﬁrst job is to tell Slick what tables we have in our database and how to map them onto Scala values and

types. The most common representaon of data in Scala is a case class, so we start by deﬁning a Message class

represenng a row in our single example table:

final case class Message(

sender: String,

content: String,

id: Long = 0L)

We also deﬁne a helper method to create a few test Messages for demonstraon purposes:

def freshTestData = Seq(

Message("Dave", "Hello, HAL. Do you read me, HAL?"),

Message("HAL", "Affirmative, Dave. I read you."),

Message("Dave", "Open the pod bay doors, HAL."),

Message("HAL", "I'm sorry, Dave. I'm afraid I can't do that.")

)

Next we deﬁne a Table object, which corresponds to our database table and tells Slick how to map back and

forth between database data and instances of our case class:

final class MessageTable(tag: Tag)

extends Table[Message](tag, "message") {

def id = column[Long]("id", O.PrimaryKey, O.AutoInc)

def sender = column[String]("sender")

def content = column[String]("content")

def * = (sender, content, id) <>

(Message.tupled, Message.unapply)

}

20 CHAPTER 1. BASICS

MessageTable deﬁnes three columns: id, sender, and content. It deﬁnes the names and types of these

columns, and any constraints on them at the database level. For example, id is a column of Long values, which

is also an auto-incremenng primary key.

The * method provides a default projecon that maps between columns in the table and instances of our case

class. Slick’s <> method deﬁnes a two-way mapping between three columns and the three ﬁelds in Message,

via the standard tupled and unapply methods generated as part of the case class. We’ll cover projecons and

default projecons in detail in Chapter 5. For now, all we need to know is that this line allows us to query the

database and get back Messages instead of tuples of (String, String, Long).

The tag on the ﬁrst line is an implementaon detail that allows Slick to manage mulple uses of the table in a

single query. Think of it like a table alias in SQL. We don’t need to provide tags in our user code—Slick takes

case of them automacally.

1.4.4 Example Queries

Slick allows us to deﬁne and compose queries in advance of running them against the database. We start by

deﬁning a TableQuery object that represents a simple SELECT * style query on our message table:

val messages = TableQuery[MessageTable]

Note that we’re not running this query at the moment—we’re simply deﬁning it as a means to build other queries.

For example, we can create a SELECT * WHERE style query using a combinator called filter:

val halSays = messages.filter(_.sender === "HAL")

Again, we haven’t run this query yet—we’ve simply deﬁned it as a useful building block for yet more queries.

This demonstrates an important part of Slick’s query language—it is made from composable building blocks that

permit a lot of valuable code re-use.

Tip

Lied Embedding

If you’re a fan of terminology, know that what we have discussed so far is called the lied embedding

approach in Slick:

• deﬁne data types to store row data (case classes, tuples, or other types);

• deﬁne Table objects represenng mappings between our data types and the database;

• deﬁne TableQueries and combinators to build useful queries before we run them against the

database.

Lied embedding is the standard way to work with Slick. We will discuss the other approach, called Plain

SQL querying, in Chapter 7.

1.4.5 Conﬁguring the Database

We’ve wrien all of the code so far without connecng to the database. Now it’s me to open a connecon

and run some SQL. We start by deﬁning a Database object, which acts as a factory for managing connecons

and transacons:

剩余153页未读，继续阅读

muyilee

粉丝: 18
资源: 10

Essential Slick 3滑块库基础教程

前端项目-react-slick.zip

Angular-ngx-slick.zip

vue-slick中文文档

vue3 ts 使用vue-slick

vue-slick-carousel

vue slick carousel 配置文档

vue slick carousel

react环状轮播

vue3 横向滚动插件

vue 3 实现轮播图

最新资源